igraph_dl_yylex: 1152| 10.1M|{ 1153| 10.1M| yy_state_type yy_current_state; 1154| 10.1M| char *yy_cp, *yy_bp; 1155| 10.1M| int yy_act; 1156| 10.1M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1157| | 1158| 10.1M| yylval = yylval_param; ------------------ | | 965| 10.1M| # define yylval yyg->yylval_r ------------------ 1159| | 1160| 10.1M| yylloc = yylloc_param; ------------------ | | 967| 10.1M| # define yylloc yyg->yylloc_r ------------------ 1161| | 1162| 10.1M| if ( !yyg->yy_init ) ------------------ | Branch (1162:7): [True: 2.33k, False: 10.1M] ------------------ 1163| 2.33k| { 1164| 2.33k| yyg->yy_init = 1; 1165| | 1166| |#ifdef YY_USER_INIT 1167| | YY_USER_INIT; 1168| |#endif 1169| | 1170| 2.33k| if ( ! yyg->yy_start ) ------------------ | Branch (1170:8): [True: 2.33k, False: 0] ------------------ 1171| 2.33k| yyg->yy_start = 1; /* first start state */ 1172| | 1173| 2.33k| if ( ! yyin ) ------------------ | | 356| 2.33k|#define yyin yyg->yyin_r ------------------ | Branch (1173:8): [True: 0, False: 2.33k] ------------------ 1174| 0| yyin = stdin; ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 1175| | 1176| 2.33k| if ( ! yyout ) ------------------ | | 357| 2.33k|#define yyout yyg->yyout_r ------------------ | Branch (1176:8): [True: 2.33k, False: 0] ------------------ 1177| 2.33k| yyout = stdout; ------------------ | | 357| 2.33k|#define yyout yyg->yyout_r ------------------ 1178| | 1179| 2.33k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 521| 2.33k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 0, False: 2.33k] | | ------------------ | | 522| 2.33k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.33k| : NULL) ------------------ | Branch (1179:8): [True: 2.33k, False: 0] ------------------ 1180| 2.33k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 2.33k|#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack ------------------ 1181| 2.33k| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 527| 2.33k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1182| 2.33k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 2.33k|#define yy_create_buffer igraph_dl_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 2.33k|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 2.33k|#define YY_BUF_SIZE 16384 ------------------ 1183| 2.33k| } 1184| | 1185| 2.33k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.33k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1186| 2.33k| } 1187| | 1188| 10.1M| { 1189| 10.1M|#line 81 "/src/igraph/src/io/dl-lexer.l" 1190| | 1191| | 1192| 10.1M|#line 1193 "/src/igraph/build/src/io/parsers/dl-lexer.c" 1193| | 1194| 17.1M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1194:23): [Folded - Ignored] ------------------ 1195| 17.1M| { 1196| 17.1M| yy_cp = yyg->yy_c_buf_p; 1197| | 1198| | /* Support of yytext. */ 1199| 17.1M| *yy_cp = yyg->yy_hold_char; 1200| | 1201| | /* yy_bp points to the position in yy_ch_buf of the start of 1202| | * the current run. 1203| | */ 1204| 17.1M| yy_bp = yy_cp; 1205| | 1206| 17.1M| yy_current_state = yyg->yy_start; 1207| 17.1M|yy_match: 1208| 17.1M| do 1209| 52.5M| { 1210| 52.5M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 52.5M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1211| 52.5M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1211:9): [True: 47.5M, False: 4.97M] ------------------ 1212| 47.5M| { 1213| 47.5M| yyg->yy_last_accepting_state = yy_current_state; 1214| 47.5M| yyg->yy_last_accepting_cpos = yy_cp; 1215| 47.5M| } 1216| 83.8M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1216:12): [True: 31.3M, False: 52.5M] ------------------ 1217| 31.3M| { 1218| 31.3M| yy_current_state = (int) yy_def[yy_current_state]; 1219| 31.3M| if ( yy_current_state >= 129 ) ------------------ | Branch (1219:10): [True: 16.8M, False: 14.4M] ------------------ 1220| 16.8M| yy_c = yy_meta[yy_c]; 1221| 31.3M| } 1222| 52.5M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1223| 52.5M| ++yy_cp; 1224| 52.5M| } 1225| 52.5M| while ( yy_base[yy_current_state] != 493 ); ------------------ | Branch (1225:11): [True: 35.3M, False: 17.1M] ------------------ 1226| | 1227| 17.1M|yy_find_action: 1228| 17.1M| yy_act = yy_accept[yy_current_state]; 1229| 17.1M| if ( yy_act == 0 ) ------------------ | Branch (1229:8): [True: 14.2M, False: 2.91M] ------------------ 1230| 14.2M| { /* have to back up */ 1231| 14.2M| yy_cp = yyg->yy_last_accepting_cpos; 1232| 14.2M| yy_current_state = yyg->yy_last_accepting_state; 1233| 14.2M| yy_act = yy_accept[yy_current_state]; 1234| 14.2M| } 1235| | 1236| 17.1M| YY_DO_BEFORE_ACTION; ------------------ | | 588| 17.1M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 577| 17.1M|#define yytext_ptr yytext_r | | ------------------ | | 589| 17.1M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 359| 17.1M|#define yyleng yyg->yyleng_r | | ------------------ | | 590| 17.1M| yyg->yy_hold_char = *yy_cp; \ | | 591| 17.1M| *yy_cp = '\0'; \ | | 592| 17.1M| yyg->yy_c_buf_p = yy_cp; ------------------ 1237| | 1238| 17.1M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 594| 34.3M|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1238:8): [True: 17.1M, False: 11.7k] | Branch (1238:38): [True: 2.30M, False: 14.8M] ------------------ 1239| 2.30M| { 1240| 2.30M| int yyl; 1241| 4.60M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 359| 4.60M|#define yyleng yyg->yyleng_r ------------------ | Branch (1241:19): [True: 2.30M, False: 2.30M] ------------------ 1242| 2.30M| if ( yytext[yyl] == '\n' ) ------------------ | | 360| 2.30M|#define yytext yyg->yytext_r ------------------ | Branch (1242:10): [True: 2.30M, False: 1.14k] ------------------ 1243| | 1244| 2.30M| do{ yylineno++; ------------------ | | 361| 2.30M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 527| 2.30M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1245| 2.30M| yycolumn=0; ------------------ | | 362| 2.30M|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 527| 2.30M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1246| 2.30M| }while(0) ------------------ | Branch (1246:12): [Folded - Ignored] ------------------ 1247| 2.30M|; 1248| 2.30M| } 1249| | 1250| 17.1M|do_action: /* This label is used only to access EOF actions. */ 1251| | 1252| 17.1M| switch ( yy_act ) 1253| 17.1M| { /* beginning of action switch */ 1254| 0| case 0: /* must back up */ ------------------ | Branch (1254:4): [True: 0, False: 17.1M] ------------------ 1255| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1256| 0| *yy_cp = yyg->yy_hold_char; 1257| 0| yy_cp = yyg->yy_last_accepting_cpos; 1258| 0| yy_current_state = yyg->yy_last_accepting_state; 1259| 0| goto yy_find_action; 1260| | 1261| 2.30M|case 1: ------------------ | Branch (1261:1): [True: 2.30M, False: 14.8M] ------------------ 1262| |/* rule 1 can match eol */ 1263| 2.30M|YY_RULE_SETUP ------------------ | | 1147| 2.30M| YY_USER_ACTION | | ------------------ | | | | 891| 2.30M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.30M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.30M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.30M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1264| 2.30M|#line 83 "/src/igraph/src/io/dl-lexer.l" 1265| 2.30M|{ return NEWLINE; } 1266| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1267| 2.20k|case 2: ------------------ | Branch (1267:1): [True: 2.20k, False: 17.1M] ------------------ 1268| 2.20k|YY_RULE_SETUP ------------------ | | 1147| 2.20k| YY_USER_ACTION | | ------------------ | | | | 891| 2.20k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.20k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.20k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1269| 2.20k|#line 85 "/src/igraph/src/io/dl-lexer.l" 1270| 2.20k|{ return DL; } 1271| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1272| 2.19k|case 3: ------------------ | Branch (1272:1): [True: 2.19k, False: 17.1M] ------------------ 1273| 2.19k|YY_RULE_SETUP ------------------ | | 1147| 2.19k| YY_USER_ACTION | | ------------------ | | | | 891| 2.19k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.19k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1274| 2.19k|#line 86 "/src/igraph/src/io/dl-lexer.l" 1275| 2.19k|{ return NEQ; } 1276| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1277| 2.20k|case 4: ------------------ | Branch (1277:1): [True: 2.20k, False: 17.1M] ------------------ 1278| 2.20k|YY_RULE_SETUP ------------------ | | 1147| 2.20k| YY_USER_ACTION | | ------------------ | | | | 891| 2.20k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.20k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.20k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1279| 2.20k|#line 87 "/src/igraph/src/io/dl-lexer.l" 1280| 2.20k|{ return NUM; } 1281| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1282| 2.04k|case 5: ------------------ | Branch (1282:1): [True: 2.04k, False: 17.1M] ------------------ 1283| 2.04k|YY_RULE_SETUP ------------------ | | 1147| 2.04k| YY_USER_ACTION | | ------------------ | | | | 891| 2.04k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.04k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.04k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1284| 2.04k|#line 89 "/src/igraph/src/io/dl-lexer.l" 1285| 2.04k|{ 1286| 2.04k| switch (yyextra->mode) { ------------------ | | 358| 2.04k|#define yyextra yyg->yyextra_r ------------------ | Branch (1286:11): [True: 0, False: 2.04k] ------------------ 1287| 469| case 0: BEGIN(FULLMATRIX); ------------------ | | 369| 469|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 0: BEGIN(FULLMATRIX); ------------------ | | 907| 469|#define FULLMATRIX 2 ------------------ | Branch (1287:3): [True: 469, False: 1.57k] ------------------ 1288| 469| break; 1289| 1.04k| case 1: BEGIN(EDGELIST); ------------------ | | 369| 1.04k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 1: BEGIN(EDGELIST); ------------------ | | 908| 1.04k|#define EDGELIST 3 ------------------ | Branch (1289:3): [True: 1.04k, False: 995] ------------------ 1290| 1.04k| break; 1291| 526| case 2: BEGIN(NODELIST); ------------------ | | 369| 526|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 2: BEGIN(NODELIST); ------------------ | | 909| 526|#define NODELIST 4 ------------------ | Branch (1291:3): [True: 526, False: 1.51k] ------------------ 1292| 526| break; 1293| 2.04k| } 1294| 2.04k| return DATA; } 1295| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1296| 337|case 6: ------------------ | Branch (1296:1): [True: 337, False: 17.1M] ------------------ 1297| 337|YY_RULE_SETUP ------------------ | | 1147| 337| YY_USER_ACTION | | ------------------ | | | | 891| 337|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 337| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 337|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 337|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1298| 337|#line 100 "/src/igraph/src/io/dl-lexer.l" 1299| 337|{ BEGIN(LABELM); return LABELS; } ------------------ | | 369| 337|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(LABELM); return LABELS; } ------------------ | | 906| 337|#define LABELM 1 ------------------ 1300| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1301| 399|case 7: ------------------ | Branch (1301:1): [True: 399, False: 17.1M] ------------------ 1302| 399|YY_RULE_SETUP ------------------ | | 1147| 399| YY_USER_ACTION | | ------------------ | | | | 891| 399|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 399| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 399|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 399|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1303| 399|#line 101 "/src/igraph/src/io/dl-lexer.l" 1304| 399|{ 1305| 399| return LABELSEMBEDDED; } 1306| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1307| 4|case 8: ------------------ | Branch (1307:1): [True: 4, False: 17.1M] ------------------ 1308| 4|YY_RULE_SETUP ------------------ | | 1147| 4| YY_USER_ACTION | | ------------------ | | | | 891| 4|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1309| 4|#line 103 "/src/igraph/src/io/dl-lexer.l" 1310| 4|{ 1311| 4| yyextra->mode=0; return FORMATFULLMATRIX; } ------------------ | | 358| 4|#define yyextra yyg->yyextra_r ------------------ 1312| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1313| 1.06k|case 9: ------------------ | Branch (1313:1): [True: 1.06k, False: 17.1M] ------------------ 1314| 1.06k|YY_RULE_SETUP ------------------ | | 1147| 1.06k| YY_USER_ACTION | | ------------------ | | | | 891| 1.06k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.06k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.06k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1315| 1.06k|#line 105 "/src/igraph/src/io/dl-lexer.l" 1316| 1.06k|{ 1317| 1.06k| yyextra->mode=1; return FORMATEDGELIST1; } ------------------ | | 358| 1.06k|#define yyextra yyg->yyextra_r ------------------ 1318| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1319| 538|case 10: ------------------ | Branch (1319:1): [True: 538, False: 17.1M] ------------------ 1320| 538|YY_RULE_SETUP ------------------ | | 1147| 538| YY_USER_ACTION | | ------------------ | | | | 891| 538|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 538| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 538|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 538|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1321| 538|#line 107 "/src/igraph/src/io/dl-lexer.l" 1322| 538|{ 1323| 538| yyextra->mode=2; return FORMATNODELIST1; } ------------------ | | 358| 538|#define yyextra yyg->yyextra_r ------------------ 1324| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1325| 2.88k|case 11: ------------------ | Branch (1325:1): [True: 2.88k, False: 17.1M] ------------------ 1326| 2.88k|YY_RULE_SETUP ------------------ | | 1147| 2.88k| YY_USER_ACTION | | ------------------ | | | | 891| 2.88k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.88k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.88k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1327| 2.88k|#line 110 "/src/igraph/src/io/dl-lexer.l" 1328| 2.88k|{ /* eaten up */ } 1329| 2.88k| YY_BREAK ------------------ | | 1143| 2.88k|#define YY_BREAK /*LINTED*/break; ------------------ 1330| 1.60M|case 12: ------------------ | Branch (1330:1): [True: 1.60M, False: 15.5M] ------------------ 1331| 1.60M|YY_RULE_SETUP ------------------ | | 1147| 1.60M| YY_USER_ACTION | | ------------------ | | | | 891| 1.60M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.60M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.60M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.60M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1332| 1.60M|#line 111 "/src/igraph/src/io/dl-lexer.l" 1333| 1.60M|{ return LABEL; } 1334| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1335| 30.4k|case 13: ------------------ | Branch (1335:1): [True: 30.4k, False: 17.1M] ------------------ 1336| 30.4k|YY_RULE_SETUP ------------------ | | 1147| 30.4k| YY_USER_ACTION | | ------------------ | | | | 891| 30.4k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 30.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 30.4k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 30.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1337| 30.4k|#line 113 "/src/igraph/src/io/dl-lexer.l" 1338| 30.4k|{ return DIGIT; } 1339| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1340| 2.34k|case 14: ------------------ | Branch (1340:1): [True: 2.34k, False: 17.1M] ------------------ 1341| 2.34k|YY_RULE_SETUP ------------------ | | 1147| 2.34k| YY_USER_ACTION | | ------------------ | | | | 891| 2.34k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.34k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1342| 2.34k|#line 114 "/src/igraph/src/io/dl-lexer.l" 1343| 2.34k|{ return LABEL; } 1344| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1345| 2.91M|case 15: ------------------ | Branch (1345:1): [True: 2.91M, False: 14.2M] ------------------ 1346| 2.91M|YY_RULE_SETUP ------------------ | | 1147| 2.91M| YY_USER_ACTION | | ------------------ | | | | 891| 2.91M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.91M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.91M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.91M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1347| 2.91M|#line 115 "/src/igraph/src/io/dl-lexer.l" 1348| 2.91M|{ } 1349| 2.91M| YY_BREAK ------------------ | | 1143| 2.91M|#define YY_BREAK /*LINTED*/break; ------------------ 1350| 4.68M|case 16: ------------------ | Branch (1350:1): [True: 4.68M, False: 12.5M] ------------------ 1351| 4.68M|YY_RULE_SETUP ------------------ | | 1147| 4.68M| YY_USER_ACTION | | ------------------ | | | | 891| 4.68M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 4.68M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 4.68M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 4.68M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1352| 4.68M|#line 117 "/src/igraph/src/io/dl-lexer.l" 1353| 4.68M|{ return NUM; } 1354| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1355| 1.20k|case 17: ------------------ | Branch (1355:1): [True: 1.20k, False: 17.1M] ------------------ 1356| 1.20k|YY_RULE_SETUP ------------------ | | 1147| 1.20k| YY_USER_ACTION | | ------------------ | | | | 891| 1.20k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.20k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.20k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1357| 1.20k|#line 118 "/src/igraph/src/io/dl-lexer.l" 1358| 1.20k|{ return LABEL; } 1359| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1360| 2.52M|case 18: ------------------ | Branch (1360:1): [True: 2.52M, False: 14.6M] ------------------ 1361| 2.52M|YY_RULE_SETUP ------------------ | | 1147| 2.52M| YY_USER_ACTION | | ------------------ | | | | 891| 2.52M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.52M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.52M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.52M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1362| 2.52M|#line 119 "/src/igraph/src/io/dl-lexer.l" 1363| 2.52M|{ } 1364| 2.52M| YY_BREAK ------------------ | | 1143| 2.52M|#define YY_BREAK /*LINTED*/break; ------------------ 1365| 1.55M|case 19: ------------------ | Branch (1365:1): [True: 1.55M, False: 15.6M] ------------------ 1366| 1.55M|YY_RULE_SETUP ------------------ | | 1147| 1.55M| YY_USER_ACTION | | ------------------ | | | | 891| 1.55M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.55M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.55M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.55M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1367| 1.55M|#line 121 "/src/igraph/src/io/dl-lexer.l" 1368| 1.55M|{ return NUM; } 1369| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1370| 6.08k|case 20: ------------------ | Branch (1370:1): [True: 6.08k, False: 17.1M] ------------------ 1371| 6.08k|YY_RULE_SETUP ------------------ | | 1147| 6.08k| YY_USER_ACTION | | ------------------ | | | | 891| 6.08k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 6.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 6.08k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 6.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1372| 6.08k|#line 122 "/src/igraph/src/io/dl-lexer.l" 1373| 6.08k|{ return LABEL; } 1374| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1375| 1.55M|case 21: ------------------ | Branch (1375:1): [True: 1.55M, False: 15.6M] ------------------ 1376| 1.55M|YY_RULE_SETUP ------------------ | | 1147| 1.55M| YY_USER_ACTION | | ------------------ | | | | 891| 1.55M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.55M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.55M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.55M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1377| 1.55M|#line 123 "/src/igraph/src/io/dl-lexer.l" 1378| 1.55M|{ } 1379| 1.55M| YY_BREAK ------------------ | | 1143| 1.55M|#define YY_BREAK /*LINTED*/break; ------------------ 1380| 54|case 22: ------------------ | Branch (1380:1): [True: 54, False: 17.1M] ------------------ 1381| 54|YY_RULE_SETUP ------------------ | | 1147| 54| YY_USER_ACTION | | ------------------ | | | | 891| 54|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 54| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 54|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 54|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1382| 54|#line 125 "/src/igraph/src/io/dl-lexer.l" 1383| 54|{ /* eaten up */ } 1384| 54| YY_BREAK ------------------ | | 1143| 54|#define YY_BREAK /*LINTED*/break; ------------------ 1385| 827|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 827|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 827|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1385:1): [True: 827, False: 17.1M] ------------------ 1386| 881|case YY_STATE_EOF(LABELM): ------------------ | | 377| 881|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 881|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1386:1): [True: 54, False: 17.1M] ------------------ 1387| 1.30k|case YY_STATE_EOF(FULLMATRIX): ------------------ | | 377| 1.30k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.30k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1387:1): [True: 423, False: 17.1M] ------------------ 1388| 1.78k|case YY_STATE_EOF(EDGELIST): ------------------ | | 377| 1.78k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.78k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1388:1): [True: 485, False: 17.1M] ------------------ 1389| 2.19k|case YY_STATE_EOF(NODELIST): ------------------ | | 377| 2.19k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.19k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1389:1): [True: 402, False: 17.1M] ------------------ 1390| 2.19k|#line 127 "/src/igraph/src/io/dl-lexer.l" 1391| 2.19k|{ 1392| 2.19k| if (yyextra->eof) { ------------------ | | 358| 2.19k|#define yyextra yyg->yyextra_r ------------------ | Branch (1392:31): [True: 793, False: 1.39k] ------------------ 1393| 793| yyterminate(); ------------------ | | 1106| 793|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 793|#define YY_NULL 0 | | ------------------ ------------------ 1394| 1.39k| } else { 1395| 1.39k| yyextra->eof=1; ------------------ | | 358| 1.39k|#define yyextra yyg->yyextra_r ------------------ 1396| 1.39k| BEGIN(INITIAL); ------------------ | | 369| 1.39k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 905| 1.39k|#define INITIAL 0 ------------------ 1397| 1.39k| return EOFF; 1398| 1.39k| } 1399| 2.19k| } 1400| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1401| 149|case 23: ------------------ | Branch (1401:1): [True: 149, False: 17.1M] ------------------ 1402| 149|YY_RULE_SETUP ------------------ | | 1147| 149| YY_USER_ACTION | | ------------------ | | | | 891| 149|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 149| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 149|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 149|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1403| 149|#line 137 "/src/igraph/src/io/dl-lexer.l" 1404| 149|{ return 0; } 1405| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1406| 0|case 24: ------------------ | Branch (1406:1): [True: 0, False: 17.1M] ------------------ 1407| 0|YY_RULE_SETUP ------------------ | | 1147| 0| YY_USER_ACTION | | ------------------ | | | | 891| 0|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1408| 0|#line 138 "/src/igraph/src/io/dl-lexer.l" 1409| 0|YY_FATAL_ERROR( "flex scanner jammed" ); ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1410| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1411| 0|#line 1412 "/src/igraph/build/src/io/parsers/dl-lexer.c" 1412| | 1413| 11.7k| case YY_END_OF_BUFFER: ------------------ | | 594| 11.7k|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1413:2): [True: 11.7k, False: 17.1M] ------------------ 1414| 11.7k| { 1415| | /* Amount of text matched not including the EOB char. */ 1416| 11.7k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 577| 11.7k|#define yytext_ptr yytext_r ------------------ 1417| | 1418| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1419| 11.7k| *yy_cp = yyg->yy_hold_char; 1420| 11.7k| YY_RESTORE_YY_MORE_OFFSET 1421| | 1422| 11.7k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 527| 11.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 498| 11.7k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1422:8): [True: 3.13k, False: 8.62k] ------------------ 1423| 3.13k| { 1424| | /* We're scanning a new file or input source. It's 1425| | * possible that this happened because the user 1426| | * just pointed yyin at a new source and called 1427| | * yylex(). If so, then we have to assure 1428| | * consistency between YY_CURRENT_BUFFER and our 1429| | * globals. Here is the right place to do so, because 1430| | * this is the first action (other than possibly a 1431| | * back-up) that will match for the new input source. 1432| | */ 1433| 3.13k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 3.13k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1434| 3.13k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 527| 3.13k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 3.13k|#define yyin yyg->yyin_r ------------------ 1435| 3.13k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 527| 3.13k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 499| 3.13k|#define YY_BUFFER_NORMAL 1 ------------------ 1436| 3.13k| } 1437| | 1438| | /* Note that here we test for yy_c_buf_p "<=" to the position 1439| | * of the first EOB in the buffer, since yy_c_buf_p will 1440| | * already have been incremented past the NUL character 1441| | * (since all states make transitions on EOB to the 1442| | * end-of-buffer state). Contrast this with the test 1443| | * in input(). 1444| | */ 1445| 11.7k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 527| 11.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1445:8): [True: 194, False: 11.5k] ------------------ 1446| 194| { /* This was really a NUL. */ 1447| 194| yy_state_type yy_next_state; 1448| | 1449| 194| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 194|#define yytext_ptr yytext_r ------------------ 1450| | 1451| 194| yy_current_state = yy_get_previous_state( yyscanner ); 1452| | 1453| | /* Okay, we're now positioned to make the NUL 1454| | * transition. We couldn't have 1455| | * yy_get_previous_state() go ahead and do it 1456| | * for us because it doesn't know how to deal 1457| | * with the possibility of jamming (and we don't 1458| | * want to build jamming into it because then it 1459| | * will run more slowly). 1460| | */ 1461| | 1462| 194| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1463| | 1464| 194| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 194|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 194|#define YY_MORE_ADJ 0 ------------------ 1465| | 1466| 194| if ( yy_next_state ) ------------------ | Branch (1466:9): [True: 66, False: 128] ------------------ 1467| 66| { 1468| | /* Consume the NUL. */ 1469| 66| yy_cp = ++yyg->yy_c_buf_p; 1470| 66| yy_current_state = yy_next_state; 1471| 66| goto yy_match; 1472| 66| } 1473| | 1474| 128| else 1475| 128| { 1476| 128| yy_cp = yyg->yy_c_buf_p; 1477| 128| goto yy_find_action; 1478| 128| } 1479| 194| } 1480| | 1481| 11.5k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1481:17): [True: 0, False: 11.5k] ------------------ 1482| 11.5k| { 1483| 2.19k| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 2.19k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1483:4): [True: 2.19k, False: 9.37k] ------------------ 1484| 2.19k| { 1485| 2.19k| yyg->yy_did_buffer_switch_on_eof = 0; 1486| | 1487| 2.19k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 2.19k|#define yywrap igraph_dl_yywrap | | ------------------ | | | | 571| 2.19k|#define igraph_dl_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (571:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1488| 2.19k| { 1489| | /* Note: because we've taken care in 1490| | * yy_get_next_buffer() to have set up 1491| | * yytext, we can now set up 1492| | * yy_c_buf_p so that if some total 1493| | * hoser (like flex itself) wants to 1494| | * call the scanner after we return the 1495| | * YY_NULL, it'll still work - another 1496| | * YY_NULL will get returned. 1497| | */ 1498| 2.19k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.19k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.19k|#define YY_MORE_ADJ 0 ------------------ 1499| | 1500| 2.19k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 2.19k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.19k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ 1501| 2.19k| goto do_action; 1502| 2.19k| } 1503| | 1504| 0| else 1505| 0| { 1506| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1506:11): [True: 0, False: 0] ------------------ 1507| 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 | | ------------------ ------------------ 1508| 0| } 1509| 0| break; 1510| 2.19k| } 1511| | 1512| 7.29k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 7.29k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1512:4): [True: 7.29k, False: 4.27k] ------------------ 1513| 7.29k| yyg->yy_c_buf_p = 1514| 7.29k| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 7.29k|#define yytext_ptr yytext_r ------------------ 1515| | 1516| 7.29k| yy_current_state = yy_get_previous_state( yyscanner ); 1517| | 1518| 7.29k| yy_cp = yyg->yy_c_buf_p; 1519| 7.29k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 7.29k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 7.29k|#define YY_MORE_ADJ 0 ------------------ 1520| 7.29k| goto yy_match; 1521| | 1522| 2.07k| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 2.07k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1522:4): [True: 2.07k, False: 9.48k] ------------------ 1523| 2.07k| yyg->yy_c_buf_p = 1524| 2.07k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 527| 2.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1525| | 1526| 2.07k| yy_current_state = yy_get_previous_state( yyscanner ); 1527| | 1528| 2.07k| yy_cp = yyg->yy_c_buf_p; 1529| 2.07k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.07k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.07k|#define YY_MORE_ADJ 0 ------------------ 1530| 2.07k| goto yy_find_action; 1531| 11.5k| } 1532| 0| break; 1533| 11.7k| } 1534| | 1535| 0| default: ------------------ | Branch (1535:2): [True: 0, False: 17.1M] ------------------ 1536| 0| YY_FATAL_ERROR( ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1537| 17.1M| "fatal flex scanner internal error--no action found" ); 1538| 17.1M| } /* end of action switch */ 1539| 17.1M| } /* end of scanning one token */ 1540| 10.1M| } /* end of user's declarations */ 1541| 10.1M|} /* end of yylex */ igraph_dl_yyrestart: 1839| 2.19k|{ 1840| 2.19k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1841| | 1842| 2.19k| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 521| 2.19k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.19k, False: 0] | | ------------------ | | 522| 2.19k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.19k| : NULL) ------------------ | Branch (1842:7): [True: 0, False: 2.19k] ------------------ 1843| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack ------------------ 1844| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1845| 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 ------------------ 1846| 0| } 1847| | 1848| 2.19k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 50| 2.19k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 521| 2.19k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.19k, False: 0] | | ------------------ | | 522| 2.19k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.19k| : NULL) ------------------ 1849| 2.19k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.19k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1850| 2.19k|} igraph_dl_yy_create_buffer: 1904| 2.33k|{ 1905| 2.33k| YY_BUFFER_STATE b; 1906| | 1907| 2.33k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 2.33k|#define yyalloc igraph_dl_yyalloc ------------------ 1908| 2.33k| if ( ! b ) ------------------ | Branch (1908:7): [True: 0, False: 2.33k] ------------------ 1909| 2.33k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1910| | 1911| 2.33k| b->yy_buf_size = size; 1912| | 1913| | /* yy_ch_buf has to be 2 characters longer than the size given because 1914| | * we need to put in 2 end-of-buffer characters. 1915| | */ 1916| 2.33k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); ------------------ | | 236| 2.33k|#define yyalloc igraph_dl_yyalloc ------------------ 1917| 2.33k| if ( ! b->yy_ch_buf ) ------------------ | Branch (1917:7): [True: 0, False: 2.33k] ------------------ 1918| 2.33k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1919| | 1920| 2.33k| b->yy_is_our_buffer = 1; 1921| | 1922| 2.33k| yy_init_buffer( b, file , yyscanner); ------------------ | | 50| 2.33k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ 1923| | 1924| 2.33k| return b; 1925| 2.33k|} igraph_dl_yy_delete_buffer: 1932| 2.33k|{ 1933| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1934| | 1935| 2.33k| if ( ! b ) ------------------ | Branch (1935:7): [True: 0, False: 2.33k] ------------------ 1936| 0| return; 1937| | 1938| 2.33k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 521| 2.33k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.33k, False: 0] | | ------------------ | | 522| 2.33k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.33k| : NULL) ------------------ | Branch (1938:7): [True: 2.33k, False: 0] ------------------ 1939| 2.33k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 527| 2.33k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1940| | 1941| 2.33k| if ( b->yy_is_our_buffer ) ------------------ | Branch (1941:7): [True: 2.33k, False: 0] ------------------ 1942| 2.33k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 1943| | 1944| 2.33k| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 1945| 2.33k|} igraph_dl_yy_flush_buffer: 1981| 4.52k|{ 1982| 4.52k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1983| 4.52k| if ( ! b ) ------------------ | Branch (1983:7): [True: 0, False: 4.52k] ------------------ 1984| 0| return; 1985| | 1986| 4.52k| b->yy_n_chars = 0; 1987| | 1988| | /* We always need two end-of-buffer characters. The first causes 1989| | * a transition to the end-of-buffer state. The second causes 1990| | * a jam in that state. 1991| | */ 1992| 4.52k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.52k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1993| 4.52k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.52k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1994| | 1995| 4.52k| b->yy_buf_pos = &b->yy_ch_buf[0]; 1996| | 1997| 4.52k| b->yy_at_bol = 1; 1998| 4.52k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 498| 4.52k|#define YY_BUFFER_NEW 0 ------------------ 1999| | 2000| 4.52k| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 521| 4.52k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.52k, False: 0] | | ------------------ | | 522| 4.52k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.52k| : NULL) ------------------ | Branch (2000:7): [True: 2.19k, False: 2.33k] ------------------ 2001| 2.19k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.19k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 2002| 4.52k|} igraph_dl_yypop_buffer_state: 2042| 2.33k|{ 2043| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2044| 2.33k| if (!YY_CURRENT_BUFFER) ------------------ | | 521| 2.33k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.33k, False: 0] | | ------------------ | | 522| 2.33k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.33k| : NULL) ------------------ | Branch (2044:6): [True: 2.33k, False: 0] ------------------ 2045| 2.33k| return; 2046| | 2047| 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) ------------------ 2048| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2049| 0| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2049:6): [True: 0, False: 0] ------------------ 2050| 0| --yyg->yy_buffer_stack_top; 2051| | 2052| 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) ------------------ 2053| 0| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 0|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 2054| 0| yyg->yy_did_buffer_switch_on_eof = 1; 2055| 0| } 2056| 0|} igraph_dl_yyget_leng: 2279| 7.84M|{ 2280| 7.84M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2281| 7.84M| return yyleng; ------------------ | | 359| 7.84M|#define yyleng yyg->yyleng_r ------------------ 2282| 7.84M|} igraph_dl_yyget_text: 2289| 7.87M|{ 2290| 7.87M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2291| 7.87M| return yytext; ------------------ | | 360| 7.87M|#define yytext yyg->yytext_r ------------------ 2292| 7.87M|} igraph_dl_yyset_extra: 2299| 4.67k|{ 2300| 4.67k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2301| 4.67k| yyextra = user_defined ; ------------------ | | 358| 4.67k|#define yyextra yyg->yyextra_r ------------------ 2302| 4.67k|} igraph_dl_yyset_in: 2341| 2.33k|{ 2342| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2343| 2.33k| yyin = _in_str ; ------------------ | | 356| 2.33k|#define yyin yyg->yyin_r ------------------ 2344| 2.33k|} igraph_dl_yylex_init_extra: 2424| 2.33k|{ 2425| 2.33k| struct yyguts_t dummy_yyguts; 2426| | 2427| 2.33k| yyset_extra (yy_user_defined, &dummy_yyguts); ------------------ | | 140| 2.33k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2428| | 2429| 2.33k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2429:9): [True: 0, False: 2.33k] ------------------ 2430| 0| errno = EINVAL; 2431| 0| return 1; 2432| 0| } 2433| | 2434| 2.33k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); ------------------ | | 236| 2.33k|#define yyalloc igraph_dl_yyalloc ------------------ 2435| | 2436| 2.33k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2436:9): [True: 0, False: 2.33k] ------------------ 2437| 0| errno = ENOMEM; 2438| 0| return 1; 2439| 0| } 2440| | 2441| | /* By setting to 0xAA, we expose bugs in 2442| | yy_init_globals. Leave at 0x00 for releases. */ 2443| 2.33k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2444| | 2445| 2.33k| yyset_extra (yy_user_defined, *ptr_yy_globals); ------------------ | | 140| 2.33k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2446| | 2447| 2.33k| return yy_init_globals ( *ptr_yy_globals ); 2448| 2.33k|} igraph_dl_yylex_destroy: 2485| 2.33k|{ 2486| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2487| | 2488| | /* Pop the buffer stack, destroying each element. */ 2489| 4.67k| while(YY_CURRENT_BUFFER){ ------------------ | | 521| 4.67k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:27): [True: 2.33k, False: 2.33k] | | | Branch (521:29): [True: 4.67k, False: 0] | | ------------------ | | 522| 4.67k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.67k| : NULL) ------------------ 2490| 2.33k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 2.33k|#define yy_delete_buffer igraph_dl_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 521| 2.33k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.33k, False: 0] | | ------------------ | | 522| 2.33k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.33k| : NULL) ------------------ 2491| 2.33k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 527| 2.33k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2492| 2.33k| yypop_buffer_state(yyscanner); ------------------ | | 80| 2.33k|#define yypop_buffer_state igraph_dl_yypop_buffer_state ------------------ 2493| 2.33k| } 2494| | 2495| | /* Destroy the stack itself. */ 2496| 2.33k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 2497| 2.33k| yyg->yy_buffer_stack = NULL; 2498| | 2499| | /* Destroy the start condition stack. */ 2500| 2.33k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 2501| 2.33k| yyg->yy_start_stack = NULL; 2502| | 2503| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 2504| | * yylex() is called, initialization will occur. */ 2505| 2.33k| yy_init_globals( yyscanner); 2506| | 2507| | /* Destroy the main struct (reentrant only). */ 2508| 2.33k| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 2509| 2.33k| yyscanner = NULL; 2510| 2.33k| return 0; 2511| 2.33k|} igraph_dl_yyalloc: 2541| 9.35k|{ 2542| 9.35k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2543| 9.35k| (void)yyg; 2544| 9.35k| return malloc(size); 2545| 9.35k|} igraph_dl_yyrealloc: 2548| 189|{ 2549| 189| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2550| 189| (void)yyg; 2551| | 2552| | /* The cast to (char *) in the following accommodates both 2553| | * implementations that use char* generic pointers, and those 2554| | * that use void* generic pointers. It works with the latter 2555| | * because both ANSI C and C++ allow castless assignment from 2556| | * any pointer type to void*, and deal with argument conversions 2557| | * as though doing an assignment. 2558| | */ 2559| 189| return realloc(ptr, size); 2560| 189|} igraph_dl_yyfree: 2563| 11.6k|{ 2564| 11.6k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2565| 11.6k| (void)yyg; 2566| 11.6k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2567| 11.6k|} dl-lexer.c:yy_get_next_buffer: 1551| 11.5k|{ 1552| 11.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1553| 11.5k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1554| 11.5k| char *source = yyg->yytext_ptr; ------------------ | | 577| 11.5k|#define yytext_ptr yytext_r ------------------ 1555| 11.5k| int number_to_move, i; 1556| 11.5k| int ret_val; 1557| | 1558| 11.5k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1558:7): [True: 0, False: 11.5k] ------------------ 1559| 11.5k| YY_FATAL_ERROR( ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1560| 11.5k| "fatal flex scanner internal error--end of buffer missed" ); 1561| | 1562| 11.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1562:7): [True: 0, False: 11.5k] ------------------ 1563| 0| { /* Don't try to fill the buffer, so this is an EOF. */ 1564| 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 (1564:8): [True: 0, False: 0] ------------------ 1565| 0| { 1566| | /* We matched a single character, the EOB, so 1567| | * treat this as a final EOF. 1568| | */ 1569| 0| return EOB_ACT_END_OF_FILE; ------------------ | | 410| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1570| 0| } 1571| | 1572| 0| else 1573| 0| { 1574| | /* We matched some text prior to the EOB, first 1575| | * process it. 1576| | */ 1577| 0| return EOB_ACT_LAST_MATCH; ------------------ | | 411| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1578| 0| } 1579| 0| } 1580| | 1581| | /* Try to read more data. */ 1582| | 1583| | /* First move last chars to start of buffer. */ 1584| 11.5k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 577| 11.5k|#define yytext_ptr yytext_r ------------------ 1585| | 1586| 348M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1586:15): [True: 348M, False: 11.5k] ------------------ 1587| 348M| *(dest++) = *(source++); 1588| | 1589| 11.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 510| 11.5k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1589:7): [True: 1.25k, False: 10.3k] ------------------ 1590| | /* don't do the read, it's not guaranteed to return an EOF, 1591| | * just force an EOF 1592| | */ 1593| 1.25k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 527| 1.25k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1594| | 1595| 10.3k| else 1596| 10.3k| { 1597| 10.3k| int num_to_read = 1598| 10.3k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 527| 10.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1599| | 1600| 10.4k| while ( num_to_read <= 0 ) ------------------ | Branch (1600:11): [True: 189, False: 10.3k] ------------------ 1601| 189| { /* Not enough room in the buffer - grow it. */ 1602| | 1603| | /* just a shorter name for the current buffer */ 1604| 189| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 527| 189|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1605| | 1606| 189| int yy_c_buf_p_offset = 1607| 189| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1608| | 1609| 189| if ( b->yy_is_our_buffer ) ------------------ | Branch (1609:9): [True: 189, False: 0] ------------------ 1610| 189| { 1611| 189| int new_size = b->yy_buf_size * 2; 1612| | 1613| 189| if ( new_size <= 0 ) ------------------ | Branch (1613:10): [True: 0, False: 189] ------------------ 1614| 0| b->yy_buf_size += b->yy_buf_size / 8; 1615| 189| else 1616| 189| b->yy_buf_size *= 2; 1617| | 1618| 189| b->yy_ch_buf = (char *) 1619| | /* Include room in for 2 EOB chars. */ 1620| 189| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 242| 189|#define yyrealloc igraph_dl_yyrealloc ------------------ 1621| 189| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1622| 189| } 1623| 0| else 1624| | /* Can't grow it, we don't own it. */ 1625| 0| b->yy_ch_buf = NULL; 1626| | 1627| 189| if ( ! b->yy_ch_buf ) ------------------ | Branch (1627:9): [True: 0, False: 189] ------------------ 1628| 189| YY_FATAL_ERROR( ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1629| 189| "fatal error - scanner input buffer overflow" ); 1630| | 1631| 189| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1632| | 1633| 189| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 527| 189|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1634| 189| number_to_move - 1; 1635| | 1636| 189| } 1637| | 1638| 10.3k| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 1053| 10.3k|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1638:8): [True: 9.67k, False: 628] ------------------ 1639| 9.67k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1053| 9.67k|#define YY_READ_BUF_SIZE 8192 ------------------ 1640| | 1641| | /* Read in more data. */ 1642| 10.3k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 1070| 10.3k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 527| 10.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (1070:7): [True: 0, False: 10.3k] | | ------------------ | | 1071| 10.3k| { \ | | 1072| 0| int c = '*'; \ | | 1073| 0| int n; \ | | 1074| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (1074:16): [True: 0, False: 0] | | ------------------ | | 1075| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1075:9): [True: 0, False: 0] | | | Branch (1075:38): [True: 0, False: 0] | | ------------------ | | 1076| 0| buf[n] = (char) c; \ | | 1077| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (1077:8): [True: 0, False: 0] | | ------------------ | | 1078| 0| buf[n++] = (char) c; \ | | 1079| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1079:8): [True: 0, False: 0] | | | Branch (1079:20): [True: 0, False: 0] | | ------------------ | | 1080| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | | | ------------------ | | | | | | 887| 0| do { \ | | | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | | | 889| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (889:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1081| 0| result = n; \ | | 1082| 0| } \ | | 1083| 10.3k| else \ | | 1084| 10.3k| { \ | | 1085| 10.3k| errno=0; \ | | 1086| 10.3k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 10.3k|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 3.01k|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1086:11): [True: 3.01k, False: 7.29k] | | | Branch (1086:78): [True: 0, False: 3.01k] | | ------------------ | | 1087| 10.3k| { \ | | 1088| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (1088:8): [True: 0, False: 0] | | ------------------ | | 1089| 0| { \ | | 1090| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | | | ------------------ | | | | | | 887| 0| do { \ | | | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | | | 889| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (889:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1091| 0| break; \ | | 1092| 0| } \ | | 1093| 0| errno=0; \ | | 1094| 0| clearerr(yyin); \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | 1095| 0| } \ | | 1096| 10.3k| }\ ------------------ 1643| 10.3k| yyg->yy_n_chars, num_to_read ); 1644| | 1645| 10.3k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 527| 10.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1646| 10.3k| } 1647| | 1648| 11.5k| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1648:7): [True: 4.27k, False: 7.29k] ------------------ 1649| 4.27k| { 1650| 4.27k| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 836| 4.27k|#define YY_MORE_ADJ 0 ------------------ | Branch (1650:8): [True: 2.19k, False: 2.07k] ------------------ 1651| 2.19k| { 1652| 2.19k| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 2.19k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1653| 2.19k| yyrestart( yyin , yyscanner); ------------------ | | 98| 2.19k|#define yyrestart igraph_dl_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 2.19k|#define yyin yyg->yyin_r ------------------ 1654| 2.19k| } 1655| | 1656| 2.07k| else 1657| 2.07k| { 1658| 2.07k| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 2.07k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1659| 2.07k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 527| 2.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1660| 2.07k| YY_BUFFER_EOF_PENDING; ------------------ | | 510| 2.07k|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1661| 2.07k| } 1662| 4.27k| } 1663| | 1664| 7.29k| else 1665| 7.29k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 7.29k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1666| | 1667| 11.5k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1667:6): [True: 0, False: 11.5k] ------------------ 1668| | /* Extend the array by 50%, plus the number we really need. */ 1669| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1670| 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 ------------------ 1671| 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] ------------------ 1672| 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 (1672:8): [True: 0, False: 0] ------------------ 1673| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1674| | /* "- 2" to take care of EOB's */ 1675| 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] ------------------ 1676| 0| } 1677| | 1678| 11.5k| yyg->yy_n_chars += number_to_move; 1679| 11.5k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 11.5k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1680| 11.5k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 11.5k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1681| | 1682| 11.5k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 577| 11.5k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1683| | 1684| 11.5k| return ret_val; 1685| 11.5k|} dl-lexer.c:yy_get_previous_state: 1690| 9.56k|{ 1691| 9.56k| yy_state_type yy_current_state; 1692| 9.56k| char *yy_cp; 1693| 9.56k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1694| | 1695| 9.56k| yy_current_state = yyg->yy_start; 1696| | 1697| 350M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 577| 9.56k|#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.56k|#define YY_MORE_ADJ 0 ------------------ | Branch (1697:47): [True: 350M, False: 9.56k] ------------------ 1698| 350M| { 1699| 350M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 46); ------------------ | | 346| 350M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1699:19): [True: 350M, False: 61] ------------------ 1700| 350M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1700:8): [True: 349M, False: 1.41M] ------------------ 1701| 349M| { 1702| 349M| yyg->yy_last_accepting_state = yy_current_state; 1703| 349M| yyg->yy_last_accepting_cpos = yy_cp; 1704| 349M| } 1705| 384M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1705:11): [True: 34.2M, False: 350M] ------------------ 1706| 34.2M| { 1707| 34.2M| yy_current_state = (int) yy_def[yy_current_state]; 1708| 34.2M| if ( yy_current_state >= 129 ) ------------------ | Branch (1708:9): [True: 32.9M, False: 1.29M] ------------------ 1709| 32.9M| yy_c = yy_meta[yy_c]; 1710| 34.2M| } 1711| 350M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1712| 350M| } 1713| | 1714| 9.56k| return yy_current_state; 1715| 9.56k|} dl-lexer.c:yy_try_NUL_trans: 1723| 194|{ 1724| 194| int yy_is_jam; 1725| 194| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ 1726| 194| char *yy_cp = yyg->yy_c_buf_p; 1727| | 1728| 194| YY_CHAR yy_c = 46; 1729| 194| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1729:7): [True: 110, False: 84] ------------------ 1730| 110| { 1731| 110| yyg->yy_last_accepting_state = yy_current_state; 1732| 110| yyg->yy_last_accepting_cpos = yy_cp; 1733| 110| } 1734| 399| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1734:10): [True: 205, False: 194] ------------------ 1735| 205| { 1736| 205| yy_current_state = (int) yy_def[yy_current_state]; 1737| 205| if ( yy_current_state >= 129 ) ------------------ | Branch (1737:8): [True: 64, False: 141] ------------------ 1738| 64| yy_c = yy_meta[yy_c]; 1739| 205| } 1740| 194| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1741| 194| yy_is_jam = (yy_current_state == 128); 1742| | 1743| 194| (void)yyg; 1744| 194| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (1744:9): [True: 128, False: 66] ------------------ 1745| 194|} dl-lexer.c:igraph_dl_yy_load_buffer_state: 1889| 6.72k|{ 1890| 6.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1891| 6.72k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 6.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1892| 6.72k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 577| 6.72k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 527| 6.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1893| 6.72k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 6.72k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 527| 6.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1894| 6.72k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1895| 6.72k|} dl-lexer.c:igraph_dl_yy_init_buffer: 1953| 4.52k|{ 1954| 4.52k| int oerrno = errno; 1955| 4.52k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1956| | 1957| 4.52k| yy_flush_buffer( b , yyscanner); ------------------ | | 56| 4.52k|#define yy_flush_buffer igraph_dl_yy_flush_buffer ------------------ 1958| | 1959| 4.52k| b->yy_input_file = file; 1960| 4.52k| b->yy_fill_buffer = 1; 1961| | 1962| | /* If b is the current buffer, then yy_init_buffer was _probably_ 1963| | * called from yyrestart() or through yy_get_next_buffer. 1964| | * In that case, we don't want to reset the lineno or column. 1965| | */ 1966| 4.52k| if (b != YY_CURRENT_BUFFER){ ------------------ | | 521| 4.52k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.52k, False: 0] | | ------------------ | | 522| 4.52k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.52k| : NULL) ------------------ | Branch (1966:9): [True: 2.33k, False: 2.19k] ------------------ 1967| 2.33k| b->yy_bs_lineno = 1; 1968| 2.33k| b->yy_bs_column = 0; 1969| 2.33k| } 1970| | 1971| 4.52k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (1971:32): [True: 4.52k, False: 0] ------------------ 1972| | 1973| 4.52k| errno = oerrno; 1974| 4.52k|} dl-lexer.c:igraph_dl_yyensure_buffer_stack: 2062| 2.33k|{ 2063| 2.33k| yy_size_t num_to_alloc; 2064| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2065| | 2066| 2.33k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2066:6): [True: 2.33k, False: 0] ------------------ 2067| | 2068| | /* First allocation is just for 2 elements, since we don't know if this 2069| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2070| | * immediate realloc on the next call. 2071| | */ 2072| 2.33k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2073| 2.33k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 2.33k|#define yyalloc igraph_dl_yyalloc ------------------ 2074| 2.33k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2075| 2.33k| , yyscanner); 2076| 2.33k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2076:8): [True: 0, False: 2.33k] ------------------ 2077| 2.33k| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2078| | 2079| 2.33k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2080| | 2081| 2.33k| yyg->yy_buffer_stack_max = num_to_alloc; 2082| 2.33k| yyg->yy_buffer_stack_top = 0; 2083| 2.33k| return; 2084| 2.33k| } 2085| | 2086| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2086:6): [True: 0, False: 0] ------------------ 2087| | 2088| | /* Increase the buffer to prepare for a possible push. */ 2089| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2090| | 2091| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2092| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 242| 0|#define yyrealloc igraph_dl_yyrealloc ------------------ 2093| 0| (yyg->yy_buffer_stack, 2094| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2095| 0| , yyscanner); 2096| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2096:8): [True: 0, False: 0] ------------------ 2097| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 887| 0| do { \ | | | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 889| 0| } while (0) | | | | ------------------ | | | | | Branch (889:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2098| | 2099| | /* zero only the new slots.*/ 2100| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2101| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2102| 0| } 2103| 0|} dl-lexer.c:yy_init_globals: 2451| 4.67k|{ 2452| 4.67k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2453| | /* Initialization is the same as for the non-reentrant scanner. 2454| | * This function is called from yylex_destroy(), so don't allocate here. 2455| | */ 2456| | 2457| 4.67k| yyg->yy_buffer_stack = NULL; 2458| 4.67k| yyg->yy_buffer_stack_top = 0; 2459| 4.67k| yyg->yy_buffer_stack_max = 0; 2460| 4.67k| yyg->yy_c_buf_p = NULL; 2461| 4.67k| yyg->yy_init = 0; 2462| 4.67k| yyg->yy_start = 0; 2463| | 2464| 4.67k| yyg->yy_start_stack_ptr = 0; 2465| 4.67k| yyg->yy_start_stack_depth = 0; 2466| 4.67k| yyg->yy_start_stack = NULL; 2467| | 2468| |/* Defined in main.c */ 2469| |#ifdef YY_STDINIT 2470| | yyin = stdin; 2471| | yyout = stdout; 2472| |#else 2473| 4.67k| yyin = NULL; ------------------ | | 356| 4.67k|#define yyin yyg->yyin_r ------------------ 2474| 4.67k| yyout = NULL; ------------------ | | 357| 4.67k|#define yyout yyg->yyout_r ------------------ 2475| 4.67k|#endif 2476| | 2477| | /* For future reference: Set errno on error, since we are called by 2478| | * yylex_init() 2479| | */ 2480| 4.67k| return 0; 2481| 4.67k|} igraph_dl_yyparse: 1291| 2.33k|{ 1292| |/* The lookahead symbol. */ 1293| 2.33k|int yychar; 1294| | 1295| | 1296| |/* The semantic value of the lookahead symbol. */ 1297| |/* Default value used for initialization, for pacifying older GCCs 1298| | or non-GCC compilers. */ 1299| 2.33k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 370| 2.33k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1300| 2.33k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 370| 2.33k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1301| | 1302| |/* Location data for the lookahead symbol. */ 1303| 2.33k|static YYLTYPE yyloc_default 1304| 2.33k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1305| 2.33k| = { 1, 1, 1, 1 } 1306| 2.33k|# endif 1307| 2.33k|; 1308| 2.33k|YYLTYPE yylloc = yyloc_default; 1309| | 1310| | /* Number of syntax errors so far. */ 1311| 2.33k| int yynerrs; 1312| | 1313| 2.33k| yy_state_fast_t yystate; 1314| | /* Number of tokens to shift before error messages enabled. */ 1315| 2.33k| int yyerrstatus; 1316| | 1317| | /* The stacks and their tools: 1318| | 'yyss': related to states. 1319| | 'yyvs': related to semantic values. 1320| | 'yyls': related to locations. 1321| | 1322| | Refer to the stacks through separate pointers, to allow yyoverflow 1323| | to reallocate them elsewhere. */ 1324| | 1325| | /* The state stack. */ 1326| 2.33k| yy_state_t yyssa[YYINITDEPTH]; 1327| 2.33k| yy_state_t *yyss; 1328| 2.33k| yy_state_t *yyssp; 1329| | 1330| | /* The semantic value stack. */ 1331| 2.33k| YYSTYPE yyvsa[YYINITDEPTH]; 1332| 2.33k| YYSTYPE *yyvs; 1333| 2.33k| YYSTYPE *yyvsp; 1334| | 1335| | /* The location stack. */ 1336| 2.33k| YYLTYPE yylsa[YYINITDEPTH]; 1337| 2.33k| YYLTYPE *yyls; 1338| 2.33k| YYLTYPE *yylsp; 1339| | 1340| | /* The locations where the error started and ended. */ 1341| 2.33k| YYLTYPE yyerror_range[3]; 1342| | 1343| 2.33k| YYPTRDIFF_T yystacksize; ------------------ | | 285| 2.33k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1344| | 1345| 2.33k| int yyn; 1346| 2.33k| int yyresult; 1347| | /* Lookahead token as an internal (translated) token number. */ 1348| 2.33k| int yytoken = 0; 1349| | /* The variables used to return semantic value and location from the 1350| | action routines. */ 1351| 2.33k| YYSTYPE yyval; 1352| 2.33k| YYLTYPE yyloc; 1353| | 1354| 2.33k|#if YYERROR_VERBOSE 1355| | /* Buffer for error messages, and its allocated size. */ 1356| 2.33k| char yymsgbuf[128]; 1357| 2.33k| char *yymsg = yymsgbuf; 1358| 2.33k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 285| 2.33k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1359| 2.33k|#endif 1360| | 1361| 2.33k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 1362| | 1363| | /* The number of symbols on the RHS of the reduced rule. 1364| | Keep to zero when no symbol should be popped. */ 1365| 2.33k| int yylen = 0; 1366| | 1367| 2.33k| yyssp = yyss = yyssa; 1368| 2.33k| yyvsp = yyvs = yyvsa; 1369| 2.33k| yylsp = yyls = yylsa; 1370| 2.33k| yystacksize = YYINITDEPTH; ------------------ | | 1016| 2.33k|# define YYINITDEPTH 200 ------------------ 1371| | 1372| 2.33k| YYDPRINTF ((stderr, "Starting parse\n")); 1373| | 1374| 2.33k| yystate = 0; 1375| 2.33k| yyerrstatus = 0; 1376| 2.33k| yynerrs = 0; ------------------ | | 71| 2.33k|#define yynerrs igraph_dl_yynerrs ------------------ 1377| 2.33k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 780| 2.33k|#define YYEMPTY (-2) ------------------ 1378| 2.33k| yylsp[0] = yylloc; 1379| 2.33k| goto yysetstate; 1380| | 1381| | 1382| |/*------------------------------------------------------------. 1383| || yynewstate -- push a new state, which is found in yystate. | 1384| |`------------------------------------------------------------*/ 1385| 25.6M|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| 25.6M| yyssp++; 1389| | 1390| | 1391| |/*--------------------------------------------------------------------. 1392| || yysetstate -- set current state (the top of the stack) to yystate. | 1393| |`--------------------------------------------------------------------*/ 1394| 25.6M|yysetstate: 1395| 25.6M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1396| 25.6M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 393| 25.6M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (393:31): [Folded - Ignored] | | | Branch (393:37): [True: 0, False: 0] | | | Branch (393:37): [True: 0, False: 0] | | ------------------ ------------------ 1397| 25.6M| YY_IGNORE_USELESS_CAST_BEGIN 1398| 25.6M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 126| 25.6M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1399| 25.6M| YY_IGNORE_USELESS_CAST_END 1400| | 1401| 25.6M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1401:7): [True: 0, False: 25.6M] ------------------ 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 - Ignored] | | ------------------ ------------------ 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 - Ignored] | | ------------------ ------------------ 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 - Ignored] | | ------------------ ------------------ 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| 25.6M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1468| | 1469| 25.6M| if (yystate == YYFINAL) ------------------ | | 527| 25.6M|#define YYFINAL 4 ------------------ | Branch (1469:7): [True: 811, False: 25.6M] ------------------ 1470| 811| YYACCEPT; ------------------ | | 783| 811|#define YYACCEPT goto yyacceptlab ------------------ 1471| | 1472| 25.6M| goto yybackup; 1473| | 1474| | 1475| |/*-----------. 1476| || yybackup. | 1477| |`-----------*/ 1478| 25.6M|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| 25.6M| yyn = yypact[yystate]; 1484| 25.6M| if (yypact_value_is_default (yyn)) ------------------ | | 632| 25.6M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 25.6M|#define YYPACT_NINF (-114) | | ------------------ | | | Branch (632:3): [True: 13.9M, False: 11.7M] | | ------------------ ------------------ 1485| 13.9M| 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.7M| if (yychar == YYEMPTY) ------------------ | | 780| 11.7M|#define YYEMPTY (-2) ------------------ | Branch (1490:7): [True: 10.1M, False: 1.51M] ------------------ 1491| 10.1M| { 1492| 10.1M| YYDPRINTF ((stderr, "Reading a token: ")); 1493| 10.1M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 68| 10.1M|#define yylex igraph_dl_yylex ------------------ yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 116| 10.1M|#define scanner context->scanner ------------------ 1494| 10.1M| } 1495| | 1496| 11.7M| if (yychar <= YYEOF) ------------------ | | 781| 11.7M|#define YYEOF 0 ------------------ | Branch (1496:7): [True: 1.00k, False: 11.7M] ------------------ 1497| 1.00k| { 1498| 1.00k| yychar = yytoken = YYEOF; ------------------ | | 781| 1.00k|#define YYEOF 0 ------------------ 1499| 1.00k| YYDPRINTF ((stderr, "Now at end of input.\n")); 1500| 1.00k| } 1501| 11.7M| else 1502| 11.7M| { 1503| 11.7M| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 11.7M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 11.7M|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 11.7M, False: 0] | | | Branch (547:18): [True: 11.7M, False: 0] | | ------------------ ------------------ 1504| 11.7M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1505| 11.7M| } 1506| | 1507| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1508| | detect an error, take that action. */ 1509| 11.7M| yyn += yytoken; 1510| 11.7M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 529| 11.7M|#define YYLAST 118 ------------------ | Branch (1510:7): [True: 0, False: 11.7M] | Branch (1510:18): [True: 0, False: 11.7M] | Branch (1510:34): [True: 1.50M, False: 10.2M] ------------------ 1511| 1.50M| goto yydefault; 1512| 10.2M| yyn = yytable[yyn]; 1513| 10.2M| if (yyn <= 0) ------------------ | Branch (1513:7): [True: 10.8k, False: 10.1M] ------------------ 1514| 10.8k| { 1515| 10.8k| if (yytable_value_is_error (yyn)) ------------------ | | 637| 10.8k| 0 | | ------------------ | | | Branch (637:3): [Folded - Ignored] | | ------------------ ------------------ 1516| 0| goto yyerrlab; 1517| 10.8k| yyn = -yyn; 1518| 10.8k| goto yyreduce; 1519| 10.8k| } 1520| | 1521| | /* Count tokens shifted since error; after three, turn off error 1522| | status. */ 1523| 10.1M| if (yyerrstatus) ------------------ | Branch (1523:7): [True: 0, False: 10.1M] ------------------ 1524| 0| yyerrstatus--; 1525| | 1526| | /* Shift the lookahead token. */ 1527| 10.1M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1528| 10.1M| yystate = yyn; 1529| 10.1M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1530| 10.1M| *++yyvsp = yylval; 1531| 10.1M| YY_IGNORE_MAYBE_UNINITIALIZED_END 1532| 10.1M| *++yylsp = yylloc; 1533| | 1534| | /* Discard the shifted token. */ 1535| 10.1M| yychar = YYEMPTY; ------------------ | | 780| 10.1M|#define YYEMPTY (-2) ------------------ 1536| 10.1M| goto yynewstate; 1537| | 1538| | 1539| |/*-----------------------------------------------------------. 1540| || yydefault -- do the default action for the current state. | 1541| |`-----------------------------------------------------------*/ 1542| 15.4M|yydefault: 1543| 15.4M| yyn = yydefact[yystate]; 1544| 15.4M| if (yyn == 0) ------------------ | Branch (1544:7): [True: 814, False: 15.4M] ------------------ 1545| 814| goto yyerrlab; 1546| 15.4M| goto yyreduce; 1547| | 1548| | 1549| |/*-----------------------------. 1550| || yyreduce -- do a reduction. | 1551| |`-----------------------------*/ 1552| 15.4M|yyreduce: 1553| | /* yyn is the number of a rule to reduce with. */ 1554| 15.4M| 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.4M| yyval = yyvsp[1-yylen]; 1565| | 1566| | /* Default location. */ 1567| 15.4M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 818| 15.4M| do \ | | 819| 15.4M| if (N) \ | | ------------------ | | | Branch (819:11): [True: 13.9M, False: 1.52M] | | ------------------ | | 820| 15.4M| { \ | | 821| 13.9M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 836| 13.9M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 822| 13.9M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 836| 13.9M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 823| 13.9M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 836| 13.9M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 824| 13.9M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 836| 13.9M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 825| 13.9M| } \ | | 826| 15.4M| else \ | | 827| 15.4M| { \ | | 828| 1.52M| (Current).first_line = (Current).last_line = \ | | 829| 1.52M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 836| 1.52M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 830| 1.52M| (Current).first_column = (Current).last_column = \ | | 831| 1.52M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 836| 1.52M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 832| 1.52M| } \ | | 833| 15.4M| while (0) | | ------------------ | | | Branch (833:12): [Folded - Ignored] | | ------------------ ------------------ 1568| 15.4M| yyerror_range[1] = yyloc; 1569| 15.4M| YY_REDUCE_PRINT (yyn); 1570| 15.4M| switch (yyn) 1571| 15.4M| { 1572| 898| case 2: ------------------ | Branch (1572:3): [True: 898, False: 15.4M] ------------------ 1573| 898|#line 104 "/src/igraph/src/io/dl-parser.y" 1574| 898| { 1575| 898| context->n=(yyvsp[-4].integer); 1576| 898| if (context->n < 0) { ------------------ | Branch (1576:7): [True: 0, False: 898] ------------------ 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 - Ignored] | | ------------------ ------------------ 1578| 0| } 1579| 898| if (context->n > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 898|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (1579:7): [True: 45, False: 853] ------------------ 1580| 45| IGRAPH_YY_ERRORF("Vertex count too large in DL file (%" IGRAPH_PRId ").", IGRAPH_EINVAL, context->n); ------------------ | | 24| 45| do { \ | | 25| 45| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 45| error_code, __VA_ARGS__) ; \ | | 27| 45| context->igraph_errno = error_code; \ | | 28| 45| YYABORT; \ | | ------------------ | | | | 784| 45|#define YYABORT goto yyabortlab | | ------------------ | | 29| 45| } while (0) | | ------------------ | | | Branch (29:14): [Folded - Ignored] | | ------------------ ------------------ 1581| 45| } 1582| 898|} 1583| 853|#line 1584 "/src/igraph/build/src/io/parsers/dl-parser.c" 1584| 853| break; 1585| | 1586| 853| case 7: ------------------ | Branch (1586:3): [True: 426, False: 15.4M] ------------------ 1587| 426|#line 118 "/src/igraph/src/io/dl-parser.y" 1588| 426| { context->type=IGRAPH_DL_MATRIX; } 1589| 426|#line 1590 "/src/igraph/build/src/io/parsers/dl-parser.c" 1590| 426| break; 1591| | 1592| 362| case 8: ------------------ | Branch (1592:3): [True: 362, False: 15.4M] ------------------ 1593| 362|#line 119 "/src/igraph/src/io/dl-parser.y" 1594| 362| { context->type=IGRAPH_DL_EDGELIST1; } 1595| 362|#line 1596 "/src/igraph/build/src/io/parsers/dl-parser.c" 1596| 362| break; 1597| | 1598| 110| case 9: ------------------ | Branch (1598:3): [True: 110, False: 15.4M] ------------------ 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.4M] ------------------ 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| 426| case 11: ------------------ | Branch (1610:3): [True: 426, False: 15.4M] ------------------ 1611| 426|#line 123 "/src/igraph/src/io/dl-parser.y" 1612| 426| {} 1613| 426|#line 1614 "/src/igraph/build/src/io/parsers/dl-parser.c" 1614| 426| break; 1615| | 1616| 334| case 14: ------------------ | Branch (1616:3): [True: 334, False: 15.4M] ------------------ 1617| 334|#line 127 "/src/igraph/src/io/dl-parser.y" 1618| 334| { } 1619| 334|#line 1620 "/src/igraph/build/src/io/parsers/dl-parser.c" 1620| 334| break; 1621| | 1622| 76| case 15: ------------------ | Branch (1622:3): [True: 76, False: 15.4M] ------------------ 1623| 76|#line 128 "/src/igraph/src/io/dl-parser.y" 1624| 76| { } 1625| 76|#line 1626 "/src/igraph/build/src/io/parsers/dl-parser.c" 1626| 76| break; 1627| | 1628| 16| case 16: ------------------ | Branch (1628:3): [True: 16, False: 15.4M] ------------------ 1629| 16|#line 129 "/src/igraph/src/io/dl-parser.y" 1630| 16| { } 1631| 16|#line 1632 "/src/igraph/build/src/io/parsers/dl-parser.c" 1632| 16| break; 1633| | 1634| 336| case 17: ------------------ | Branch (1634:3): [True: 336, False: 15.4M] ------------------ 1635| 336|#line 132 "/src/igraph/src/io/dl-parser.y" 1636| 336| {} 1637| 336|#line 1638 "/src/igraph/build/src/io/parsers/dl-parser.c" 1638| 336| break; 1639| | 1640| 1.60M| case 18: ------------------ | Branch (1640:3): [True: 1.60M, False: 13.8M] ------------------ 1641| 1.60M|#line 133 "/src/igraph/src/io/dl-parser.y" 1642| 1.60M| { 1643| 1.60M| IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.60M| do { \ | | 11| 1.60M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.60M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 1.60M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.60M] | | | | ------------------ | | ------------------ | | 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.60M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1644| 1.60M| igraph_dl_yyget_leng(scanner), 1645| 1.60M| context)); } 1646| 1.60M|#line 1647 "/src/igraph/build/src/io/parsers/dl-parser.c" 1647| 1.60M| break; 1648| | 1649| 1.60M| case 19: ------------------ | Branch (1649:3): [True: 436, False: 15.4M] ------------------ 1650| 436|#line 139 "/src/igraph/src/io/dl-parser.y" 1651| 436| {} 1652| 436|#line 1653 "/src/igraph/build/src/io/parsers/dl-parser.c" 1653| 436| break; 1654| | 1655| 10.8k| case 20: ------------------ | Branch (1655:3): [True: 10.8k, False: 15.4M] ------------------ 1656| 10.8k|#line 139 "/src/igraph/src/io/dl-parser.y" 1657| 10.8k| { 1658| 10.8k| context->from += 1; 1659| 10.8k| context->to = 0; 1660| 10.8k| } 1661| 10.8k|#line 1662 "/src/igraph/build/src/io/parsers/dl-parser.c" 1662| 10.8k| break; 1663| | 1664| 30.4k| case 22: ------------------ | Branch (1664:3): [True: 30.4k, False: 15.4M] ------------------ 1665| 30.4k|#line 144 "/src/igraph/src/io/dl-parser.y" 1666| 30.4k| { } 1667| 30.4k|#line 1668 "/src/igraph/build/src/io/parsers/dl-parser.c" 1668| 30.4k| break; 1669| | 1670| 30.4k| case 23: ------------------ | Branch (1670:3): [True: 30.4k, False: 15.4M] ------------------ 1671| 30.4k|#line 146 "/src/igraph/src/io/dl-parser.y" 1672| 30.4k| { 1673| | /* TODO: What if the digit is neither 0 or 1? Are multigraphs allowed? */ 1674| 30.4k| char c = igraph_dl_yyget_text(scanner)[0]; ------------------ | | 116| 30.4k|#define scanner context->scanner ------------------ 1675| 30.4k| if (c == '1') { ------------------ | Branch (1675:7): [True: 29.6k, False: 720] ------------------ 1676| 29.6k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 29.6k| do { \ | | 11| 29.6k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 29.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 29.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 29.6k] | | | | ------------------ | | ------------------ | | 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| 29.6k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1677| 29.6k| context->from)); 1678| 29.6k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 29.6k| do { \ | | 11| 29.6k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 29.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 29.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 29.6k] | | | | ------------------ | | ------------------ | | 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| 29.6k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1679| 29.6k| context->to)); 1680| 29.6k| } else if (c != '0') { ------------------ | Branch (1680:14): [True: 3, False: 717] ------------------ 1681| 3| IGRAPH_YY_ERRORF("Unexpected digit '%c' in adjacency matrix in DL file.", ------------------ | | 24| 3| do { \ | | 25| 3| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 3| error_code, __VA_ARGS__) ; \ | | 27| 3| context->igraph_errno = error_code; \ | | 28| 3| YYABORT; \ | | ------------------ | | | | 784| 3|#define YYABORT goto yyabortlab | | ------------------ | | 29| 3| } while (0) | | ------------------ | | | Branch (29:14): [Folded - Ignored] | | ------------------ ------------------ 1682| 3| IGRAPH_EINVAL, c); 1683| 3| } 1684| 30.4k| context->to += 1; 1685| 30.4k|} 1686| 0|#line 1687 "/src/igraph/build/src/io/parsers/dl-parser.c" 1687| 0| break; 1688| | 1689| 16| case 24: ------------------ | Branch (1689:3): [True: 16, False: 15.4M] ------------------ 1690| 16|#line 161 "/src/igraph/src/io/dl-parser.y" 1691| 16| {} 1692| 16|#line 1693 "/src/igraph/build/src/io/parsers/dl-parser.c" 1693| 16| break; 1694| | 1695| 16| case 25: ------------------ | Branch (1695:3): [True: 16, False: 15.4M] ------------------ 1696| 16|#line 163 "/src/igraph/src/io/dl-parser.y" 1697| 16| {} 1698| 16|#line 1699 "/src/igraph/build/src/io/parsers/dl-parser.c" 1699| 16| break; 1700| | 1701| 2.06k| case 28: ------------------ | Branch (1701:3): [True: 2.06k, False: 15.4M] ------------------ 1702| 2.06k|#line 167 "/src/igraph/src/io/dl-parser.y" 1703| 2.06k| { IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 2.06k| do { \ | | 11| 2.06k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.06k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 2.06k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.06k] | | | | ------------------ | | ------------------ | | 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.06k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1704| 2.06k| igraph_dl_yyget_leng(scanner), 1705| 2.06k| context)); } 1706| 2.06k|#line 1707 "/src/igraph/build/src/io/parsers/dl-parser.c" 1707| 2.06k| break; 1708| | 1709| 2.06k| case 29: ------------------ | Branch (1709:3): [True: 19, False: 15.4M] ------------------ 1710| 19|#line 171 "/src/igraph/src/io/dl-parser.y" 1711| 19| { 1712| 19| context->from += 1; 1713| 19| context->to = 0; 1714| 19| } 1715| 19|#line 1716 "/src/igraph/build/src/io/parsers/dl-parser.c" 1716| 19| break; 1717| | 1718| 215| case 30: ------------------ | Branch (1718:3): [True: 215, False: 15.4M] ------------------ 1719| 215|#line 175 "/src/igraph/src/io/dl-parser.y" 1720| 215| { 1721| 215| context->from += 1; 1722| 215| context->to = 0; 1723| 215| } 1724| 215|#line 1725 "/src/igraph/build/src/io/parsers/dl-parser.c" 1725| 215| break; 1726| | 1727| 234| case 31: ------------------ | Branch (1727:3): [True: 234, False: 15.4M] ------------------ 1728| 234|#line 180 "/src/igraph/src/io/dl-parser.y" 1729| 234| { } 1730| 234|#line 1731 "/src/igraph/build/src/io/parsers/dl-parser.c" 1731| 234| break; 1732| | 1733| 362| case 32: ------------------ | Branch (1733:3): [True: 362, False: 15.4M] ------------------ 1734| 362|#line 184 "/src/igraph/src/io/dl-parser.y" 1735| 362| {} 1736| 362|#line 1737 "/src/igraph/build/src/io/parsers/dl-parser.c" 1737| 362| break; 1738| | 1739| 332| case 33: ------------------ | Branch (1739:3): [True: 332, False: 15.4M] ------------------ 1740| 332|#line 186 "/src/igraph/src/io/dl-parser.y" 1741| 332| {} 1742| 332|#line 1743 "/src/igraph/build/src/io/parsers/dl-parser.c" 1743| 332| break; 1744| | 1745| 3| case 34: ------------------ | Branch (1745:3): [True: 3, False: 15.4M] ------------------ 1746| 3|#line 187 "/src/igraph/src/io/dl-parser.y" 1747| 3| {} 1748| 3|#line 1749 "/src/igraph/build/src/io/parsers/dl-parser.c" 1749| 3| break; 1750| | 1751| 20| case 35: ------------------ | Branch (1751:3): [True: 20, False: 15.4M] ------------------ 1752| 20|#line 188 "/src/igraph/src/io/dl-parser.y" 1753| 20| {} 1754| 20|#line 1755 "/src/igraph/build/src/io/parsers/dl-parser.c" 1755| 20| break; 1756| | 1757| 7| case 36: ------------------ | Branch (1757:3): [True: 7, False: 15.4M] ------------------ 1758| 7|#line 189 "/src/igraph/src/io/dl-parser.y" 1759| 7| {} 1760| 7|#line 1761 "/src/igraph/build/src/io/parsers/dl-parser.c" 1761| 7| break; 1762| | 1763| 0| case 37: ------------------ | Branch (1763:3): [True: 0, False: 15.4M] ------------------ 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| 926| case 38: ------------------ | Branch (1769:3): [True: 926, False: 15.4M] ------------------ 1770| 926|#line 193 "/src/igraph/src/io/dl-parser.y" 1771| 926| {} 1772| 926|#line 1773 "/src/igraph/build/src/io/parsers/dl-parser.c" 1773| 926| break; 1774| | 1775| 2.18M| case 39: ------------------ | Branch (1775:3): [True: 2.18M, False: 13.3M] ------------------ 1776| 2.18M|#line 194 "/src/igraph/src/io/dl-parser.y" 1777| 2.18M| {} 1778| 2.18M|#line 1779 "/src/igraph/build/src/io/parsers/dl-parser.c" 1779| 2.18M| break; 1780| | 1781| 317k| case 40: ------------------ | Branch (1781:3): [True: 317k, False: 15.1M] ------------------ 1782| 317k|#line 197 "/src/igraph/src/io/dl-parser.y" 1783| 317k| { 1784| 317k| igraph_integer_t from = (yyvsp[-3].integer), to = (yyvsp[-2].integer); 1785| 317k| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(from)); ------------------ | | 10| 317k| do { \ | | 11| 317k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 122, False: 317k] | | | | ------------------ | | ------------------ | | 13| 122| context->igraph_errno = igraph_i_ret; \ | | 14| 122| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 122|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 122| YYABORT; \ | | ------------------ | | | | 784| 122|#define YYABORT goto yyabortlab | | ------------------ | | 16| 122| } \ | | 17| 317k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1786| 317k| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 317k| do { \ | | 11| 317k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 127, False: 317k] | | | | ------------------ | | ------------------ | | 13| 127| context->igraph_errno = igraph_i_ret; \ | | 14| 127| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 127|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 127| YYABORT; \ | | ------------------ | | | | 784| 127|#define YYABORT goto yyabortlab | | ------------------ | | 16| 127| } \ | | 17| 317k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1787| 317k| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w(from-1, to-1, (yyvsp[-1].real), context)); } ------------------ | | 10| 317k| do { \ | | 11| 317k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 317k] | | | | ------------------ | | ------------------ | | 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| 317k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1788| 317k|#line 1789 "/src/igraph/build/src/io/parsers/dl-parser.c" 1789| 317k| break; 1790| | 1791| 1.86M| case 41: ------------------ | Branch (1791:3): [True: 1.86M, False: 13.6M] ------------------ 1792| 1.86M|#line 202 "/src/igraph/src/io/dl-parser.y" 1793| 1.86M| { 1794| 1.86M| igraph_integer_t from = (yyvsp[-2].integer), to = (yyvsp[-1].integer); 1795| 1.86M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(from)); ------------------ | | 10| 1.86M| do { \ | | 11| 1.86M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.86M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 1.86M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 122, False: 1.86M] | | | | ------------------ | | ------------------ | | 13| 122| context->igraph_errno = igraph_i_ret; \ | | 14| 122| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 122|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 122| YYABORT; \ | | ------------------ | | | | 784| 122|#define YYABORT goto yyabortlab | | ------------------ | | 16| 122| } \ | | 17| 1.86M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1796| 1.86M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 1.86M| do { \ | | 11| 1.86M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.86M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 1.86M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 121, False: 1.86M] | | | | ------------------ | | ------------------ | | 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| 1.86M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1797| 1.86M| IGRAPH_YY_CHECK(igraph_i_dl_add_edge(from-1, to-1, context)); ------------------ | | 10| 1.86M| do { \ | | 11| 1.86M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.86M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 1.86M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.86M] | | | | ------------------ | | ------------------ | | 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.86M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1798| 1.86M|} 1799| 1.86M|#line 1800 "/src/igraph/build/src/io/parsers/dl-parser.c" 1800| 1.86M| break; 1801| | 1802| 5.91M| case 42: ------------------ | Branch (1802:3): [True: 5.91M, False: 9.56M] ------------------ 1803| 5.91M|#line 209 "/src/igraph/src/io/dl-parser.y" 1804| 5.91M| { 1805| 5.91M| igraph_integer_t val; 1806| 5.91M| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 5.91M| do { \ | | 11| 5.91M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 5.91M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 5.91M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 30, False: 5.91M] | | | | ------------------ | | ------------------ | | 13| 30| context->igraph_errno = igraph_i_ret; \ | | 14| 30| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 30|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 30| YYABORT; \ | | ------------------ | | | | 784| 30|#define YYABORT goto yyabortlab | | ------------------ | | 16| 30| } \ | | 17| 5.91M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1807| 5.91M| igraph_dl_yyget_leng(scanner), 1808| 5.91M| &val)); 1809| 5.91M| (yyval.integer)=val; 1810| 5.91M|} 1811| 0|#line 1812 "/src/igraph/build/src/io/parsers/dl-parser.c" 1812| 0| break; 1813| | 1814| 119| case 43: ------------------ | Branch (1814:3): [True: 119, False: 15.4M] ------------------ 1815| 119|#line 217 "/src/igraph/src/io/dl-parser.y" 1816| 119| {} 1817| 119|#line 1818 "/src/igraph/build/src/io/parsers/dl-parser.c" 1818| 119| break; 1819| | 1820| 542| case 44: ------------------ | Branch (1820:3): [True: 542, False: 15.4M] ------------------ 1821| 542|#line 218 "/src/igraph/src/io/dl-parser.y" 1822| 542| {} 1823| 542|#line 1824 "/src/igraph/build/src/io/parsers/dl-parser.c" 1824| 542| break; 1825| | 1826| 196| case 45: ------------------ | Branch (1826:3): [True: 196, False: 15.4M] ------------------ 1827| 196|#line 221 "/src/igraph/src/io/dl-parser.y" 1828| 196| { 1829| 196| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w((yyvsp[-3].integer), (yyvsp[-2].integer), (yyvsp[-1].real), context)); } ------------------ | | 10| 196| do { \ | | 11| 196| igraph_error_t igraph_i_ret = (expr); \ | | 12| 196| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 196| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 196] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 196| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1830| 196|#line 1831 "/src/igraph/build/src/io/parsers/dl-parser.c" 1831| 196| break; 1832| | 1833| 346| case 46: ------------------ | Branch (1833:3): [True: 346, False: 15.4M] ------------------ 1834| 346|#line 223 "/src/igraph/src/io/dl-parser.y" 1835| 346| { 1836| 346| IGRAPH_YY_CHECK(igraph_i_dl_add_edge((yyvsp[-2].integer), (yyvsp[-1].integer), context)); ------------------ | | 10| 346| do { \ | | 11| 346| igraph_error_t igraph_i_ret = (expr); \ | | 12| 346| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 346| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 346] | | | | ------------------ | | ------------------ | | 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| 346| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1837| 346| } 1838| 346|#line 1839 "/src/igraph/build/src/io/parsers/dl-parser.c" 1839| 346| break; 1840| | 1841| 317k| case 47: ------------------ | Branch (1841:3): [True: 317k, False: 15.1M] ------------------ 1842| 317k|#line 227 "/src/igraph/src/io/dl-parser.y" 1843| 317k| { 1844| 317k| igraph_real_t val; 1845| 317k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_dl_yyget_text(scanner), ------------------ | | 10| 317k| do { \ | | 11| 317k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 25, False: 317k] | | | | ------------------ | | ------------------ | | 13| 25| context->igraph_errno = igraph_i_ret; \ | | 14| 25| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 25|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 25| YYABORT; \ | | ------------------ | | | | 784| 25|#define YYABORT goto yyabortlab | | ------------------ | | 16| 25| } \ | | 17| 317k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1846| 317k| igraph_dl_yyget_leng(scanner), 1847| 317k| &val)); 1848| 317k| (yyval.real)=val; 1849| 317k|} 1850| 0|#line 1851 "/src/igraph/build/src/io/parsers/dl-parser.c" 1851| 0| break; 1852| | 1853| 7.28k| case 48: ------------------ | Branch (1853:3): [True: 7.28k, False: 15.4M] ------------------ 1854| 7.28k|#line 235 "/src/igraph/src/io/dl-parser.y" 1855| 7.28k| { 1856| 7.28k| igraph_integer_t trie_id; 1857| | 1858| | /* Copy label list to trie, if needed */ 1859| 7.28k| if (igraph_strvector_size(&context->labels) != 0) { ------------------ | Branch (1859:7): [True: 155, False: 7.12k] ------------------ 1860| 155| igraph_integer_t i, id, n=igraph_strvector_size(&context->labels); 1861| 543k| for (i=0; itrie, igraph_strvector_get(&context->labels, i), &id)); ------------------ | | 10| 543k| do { \ | | 11| 543k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 543k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 543k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 543k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 543k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1863| 543k| } 1864| 155| igraph_strvector_clear(&context->labels); 1865| 155| } 1866| 7.28k| IGRAPH_YY_CHECK(igraph_trie_get_len(&context->trie, igraph_dl_yyget_text(scanner), ------------------ | | 10| 7.28k| do { \ | | 11| 7.28k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 7.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 7.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 7.28k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 7.28k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1867| 7.28k| igraph_dl_yyget_leng(scanner), &trie_id)); 1868| 7.28k| IGRAPH_ASSERT(0 <= trie_id && trie_id < IGRAPH_DL_MAX_VERTEX_COUNT); ------------------ | | 916| 7.28k| do { \ | | 917| 7.28k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 14.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 7.28k] | | | | | Branch (604:50): [True: 7.28k, False: 0] | | | | | Branch (604:50): [True: 7.28k, False: 0] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 7.28k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1869| 7.28k| (yyval.integer) = trie_id; 1870| 7.28k| } 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.4M] ------------------ 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.4M] ------------------ 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.4M] ------------------ 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| 32| case 52: ------------------ | Branch (1892:3): [True: 32, False: 15.4M] ------------------ 1893| 32|#line 258 "/src/igraph/src/io/dl-parser.y" 1894| 32| {} 1895| 32|#line 1896 "/src/igraph/build/src/io/parsers/dl-parser.c" 1896| 32| break; 1897| | 1898| 18| case 53: ------------------ | Branch (1898:3): [True: 18, False: 15.4M] ------------------ 1899| 18|#line 259 "/src/igraph/src/io/dl-parser.y" 1900| 18| {} 1901| 18|#line 1902 "/src/igraph/build/src/io/parsers/dl-parser.c" 1902| 18| break; 1903| | 1904| 0| case 54: ------------------ | Branch (1904:3): [True: 0, False: 15.4M] ------------------ 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| 286| case 55: ------------------ | Branch (1910:3): [True: 286, False: 15.4M] ------------------ 1911| 286|#line 263 "/src/igraph/src/io/dl-parser.y" 1912| 286| {} 1913| 286|#line 1914 "/src/igraph/build/src/io/parsers/dl-parser.c" 1914| 286| break; 1915| | 1916| 460| case 56: ------------------ | Branch (1916:3): [True: 460, False: 15.4M] ------------------ 1917| 460|#line 264 "/src/igraph/src/io/dl-parser.y" 1918| 460| {} 1919| 460|#line 1920 "/src/igraph/build/src/io/parsers/dl-parser.c" 1920| 460| break; 1921| | 1922| 460| case 57: ------------------ | Branch (1922:3): [True: 460, False: 15.4M] ------------------ 1923| 460|#line 267 "/src/igraph/src/io/dl-parser.y" 1924| 460| {} 1925| 460|#line 1926 "/src/igraph/build/src/io/parsers/dl-parser.c" 1926| 460| break; 1927| | 1928| 686| case 58: ------------------ | Branch (1928:3): [True: 686, False: 15.4M] ------------------ 1929| 686|#line 269 "/src/igraph/src/io/dl-parser.y" 1930| 686| { 1931| 686| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 686| do { \ | | 11| 686| igraph_error_t igraph_i_ret = (expr); \ | | 12| 686| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 686| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 8, False: 678] | | | | ------------------ | | ------------------ | | 13| 8| context->igraph_errno = igraph_i_ret; \ | | 14| 8| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 8|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 8| YYABORT; \ | | ------------------ | | | | 784| 8|#define YYABORT goto yyabortlab | | ------------------ | | 16| 8| } \ | | 17| 686| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1932| 686| igraph_dl_yyget_leng(scanner), 1933| 686| &context->from)); 1934| 678| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(context->from)); ------------------ | | 10| 678| do { \ | | 11| 678| igraph_error_t igraph_i_ret = (expr); \ | | 12| 678| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 678| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 58, False: 620] | | | | ------------------ | | ------------------ | | 13| 58| context->igraph_errno = igraph_i_ret; \ | | 14| 58| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 58|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 58| YYABORT; \ | | ------------------ | | | | 784| 58|#define YYABORT goto yyabortlab | | ------------------ | | 16| 58| } \ | | 17| 678| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1935| 678|} 1936| 620|#line 1937 "/src/igraph/build/src/io/parsers/dl-parser.c" 1937| 620| break; 1938| | 1939| 620| case 59: ------------------ | Branch (1939:3): [True: 620, False: 15.4M] ------------------ 1940| 620|#line 276 "/src/igraph/src/io/dl-parser.y" 1941| 620| {} 1942| 620|#line 1943 "/src/igraph/build/src/io/parsers/dl-parser.c" 1943| 620| break; 1944| | 1945| 1.54M| case 60: ------------------ | Branch (1945:3): [True: 1.54M, False: 13.9M] ------------------ 1946| 1.54M|#line 276 "/src/igraph/src/io/dl-parser.y" 1947| 1.54M| { 1948| 1.54M| igraph_integer_t to = (yyvsp[0].integer); 1949| 1.54M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 1.54M| do { \ | | 11| 1.54M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.54M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 1.54M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 52, False: 1.54M] | | | | ------------------ | | ------------------ | | 13| 52| context->igraph_errno = igraph_i_ret; \ | | 14| 52| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 52|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 52| YYABORT; \ | | ------------------ | | | | 784| 52|#define YYABORT goto yyabortlab | | ------------------ | | 16| 52| } \ | | 17| 1.54M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1950| 1.54M| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 1.54M| do { \ | | 11| 1.54M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.54M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 1.54M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.54M] | | | | ------------------ | | ------------------ | | 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.54M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1951| 1.54M| context->from-1)); 1952| 1.54M| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, to-1)); ------------------ | | 10| 1.54M| do { \ | | 11| 1.54M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.54M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 1.54M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.54M] | | | | ------------------ | | ------------------ | | 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.54M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1953| 1.54M| } 1954| 1.54M|#line 1955 "/src/igraph/build/src/io/parsers/dl-parser.c" 1955| 1.54M| break; 1956| | 1957| 1.54M| case 61: ------------------ | Branch (1957:3): [True: 240, False: 15.4M] ------------------ 1958| 240|#line 284 "/src/igraph/src/io/dl-parser.y" 1959| 240| {} 1960| 240|#line 1961 "/src/igraph/build/src/io/parsers/dl-parser.c" 1961| 240| break; 1962| | 1963| 2.76k| case 62: ------------------ | Branch (1963:3): [True: 2.76k, False: 15.4M] ------------------ 1964| 2.76k|#line 285 "/src/igraph/src/io/dl-parser.y" 1965| 2.76k| {} 1966| 2.76k|#line 1967 "/src/igraph/build/src/io/parsers/dl-parser.c" 1967| 2.76k| break; 1968| | 1969| 2.76k| case 63: ------------------ | Branch (1969:3): [True: 2.76k, False: 15.4M] ------------------ 1970| 2.76k|#line 288 "/src/igraph/src/io/dl-parser.y" 1971| 2.76k| { } 1972| 2.76k|#line 1973 "/src/igraph/build/src/io/parsers/dl-parser.c" 1973| 2.76k| break; 1974| | 1975| 2.95k| case 64: ------------------ | Branch (1975:3): [True: 2.95k, False: 15.4M] ------------------ 1976| 2.95k|#line 290 "/src/igraph/src/io/dl-parser.y" 1977| 2.95k| { 1978| 2.95k| context->from=(yyvsp[0].integer); 1979| 2.95k| } 1980| 2.95k|#line 1981 "/src/igraph/build/src/io/parsers/dl-parser.c" 1981| 2.95k| break; 1982| | 1983| 3.13k| case 66: ------------------ | Branch (1983:3): [True: 3.13k, False: 15.4M] ------------------ 1984| 3.13k|#line 294 "/src/igraph/src/io/dl-parser.y" 1985| 3.13k| { 1986| 3.13k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 3.13k| do { \ | | 11| 3.13k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.13k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 3.13k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.13k] | | | | ------------------ | | ------------------ | | 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.13k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1987| 3.13k| context->from)); 1988| 3.13k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, (yyvsp[0].integer))); ------------------ | | 10| 3.13k| do { \ | | 11| 3.13k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.13k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 604| 3.13k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.13k] | | | | ------------------ | | ------------------ | | 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.13k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1989| 3.13k| } 1990| 3.13k|#line 1991 "/src/igraph/build/src/io/parsers/dl-parser.c" 1991| 3.13k| break; 1992| | 1993| | 1994| 3.13k|#line 1995 "/src/igraph/build/src/io/parsers/dl-parser.c" 1995| | 1996| 1.62M| default: break; ------------------ | Branch (1996:7): [True: 1.62M, False: 13.8M] ------------------ 1997| 15.4M| } 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.4M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2010| | 2011| 15.4M| YYPOPSTACK (yylen); ------------------ | | 1361| 15.4M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2012| 15.4M| yylen = 0; 2013| 15.4M| YY_STACK_PRINT (yyss, yyssp); 2014| | 2015| 15.4M| *++yyvsp = yyval; 2016| 15.4M| *++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.4M| { 2022| 15.4M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 532| 15.4M|#define YYNTOKENS 17 ------------------ 2023| 15.4M| const int yyi = yypgoto[yylhs] + *yyssp; 2024| 15.4M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 529| 26.7M|#define YYLAST 118 ------------------ | Branch (2024:16): [True: 11.2M, False: 4.21M] | Branch (2024:28): [True: 10.6M, False: 622k] | Branch (2024:45): [True: 6.52M, False: 4.11M] ------------------ 2025| 15.4M| ? yytable[yyi] 2026| 15.4M| : yydefgoto[yylhs]); 2027| 15.4M| } 2028| | 2029| 15.4M| goto yynewstate; 2030| | 2031| | 2032| |/*--------------------------------------. 2033| || yyerrlab -- here on detecting error. | 2034| |`--------------------------------------*/ 2035| 814|yyerrlab: 2036| | /* Make sure we have latest lookahead translation. See comments at 2037| | user semantic actions for why this is necessary. */ 2038| 814| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 814|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 547| 1.62k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 814|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 814, False: 0] | | | Branch (547:18): [True: 814, False: 0] | | ------------------ ------------------ | Branch (2038:13): [True: 0, False: 814] ------------------ 2039| | 2040| | /* If not already recovering from an error, report this error. */ 2041| 814| if (!yyerrstatus) ------------------ | Branch (2041:7): [True: 814, False: 0] ------------------ 2042| 814| { 2043| 814| ++yynerrs; ------------------ | | 71| 814|#define yynerrs igraph_dl_yynerrs ------------------ 2044| |#if ! YYERROR_VERBOSE 2045| | yyerror (&yylloc, context, YY_("syntax error")); 2046| |#else 2047| 814|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2048| 814| yyssp, yytoken) 2049| 814| { 2050| 814| char const *yymsgp = YY_("syntax error"); ------------------ | | 334| 814|# define YY_(Msgid) Msgid ------------------ 2051| 814| int yysyntax_error_status; 2052| 814| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 2047| 814|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 2048| 814| yyssp, yytoken) ------------------ 2053| 814| if (yysyntax_error_status == 0) ------------------ | Branch (2053:13): [True: 814, False: 0] ------------------ 2054| 814| 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| 814| yyerror (&yylloc, context, yymsgp); ------------------ | | 69| 814|#define yyerror igraph_dl_yyerror ------------------ 2073| 814| if (yysyntax_error_status == 2) ------------------ | Branch (2073:13): [True: 0, False: 814] ------------------ 2074| 0| goto yyexhaustedlab; 2075| 814| } 2076| 814|# undef YYSYNTAX_ERROR 2077| 814|#endif 2078| 814| } 2079| | 2080| 814| yyerror_range[1] = yylloc; 2081| | 2082| 814| if (yyerrstatus == 3) ------------------ | Branch (2082:7): [True: 0, False: 814] ------------------ 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| 814| goto yyerrlab1; 2104| | 2105| | 2106| |/*---------------------------------------------------. 2107| || yyerrorlab -- error raised explicitly by YYERROR. | 2108| |`---------------------------------------------------*/ 2109| 814|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 - Ignored] ------------------ 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| 814|yyerrlab1: 2128| 814| yyerrstatus = 3; /* Each real token shifted decrements this. */ 2129| | 2130| 814| for (;;) 2131| 8.11k| { 2132| 8.11k| yyn = yypact[yystate]; 2133| 8.11k| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 8.11k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 8.11k|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (2133:11): [True: 7.08k, False: 1.02k] ------------------ 2134| 7.08k| { 2135| 7.08k| yyn += YYTERROR; ------------------ | | 808| 7.08k|#define YYTERROR 1 ------------------ 2136| 7.08k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 529| 14.1k|#define YYLAST 118 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 808| 7.08k|#define YYTERROR 1 ------------------ | Branch (2136:15): [True: 7.08k, False: 0] | Branch (2136:27): [True: 7.08k, False: 0] | Branch (2136:44): [True: 0, False: 7.08k] ------------------ 2137| 0| { 2138| 0| yyn = yytable[yyn]; 2139| 0| if (0 < yyn) ------------------ | Branch (2139:19): [True: 0, False: 0] ------------------ 2140| 0| break; 2141| 0| } 2142| 7.08k| } 2143| | 2144| | /* Pop the current state because it cannot handle the error token. */ 2145| 8.11k| if (yyssp == yyss) ------------------ | Branch (2145:11): [True: 814, False: 7.29k] ------------------ 2146| 814| YYABORT; ------------------ | | 784| 814|#define YYABORT goto yyabortlab ------------------ 2147| | 2148| 7.29k| yyerror_range[1] = *yylsp; 2149| 7.29k| yydestruct ("Error: popping", 2150| 7.29k| yystos[yystate], yyvsp, yylsp, context); 2151| 7.29k| YYPOPSTACK (1); ------------------ | | 1361| 7.29k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2152| 7.29k| yystate = *yyssp; 2153| 7.29k| YY_STACK_PRINT (yyss, yyssp); 2154| 7.29k| } 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): [Folded - Ignored] | | ------------------ | | 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 - Ignored] | | ------------------ ------------------ 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| 811|yyacceptlab: 2177| 811| yyresult = 0; 2178| 811| goto yyreturn; 2179| | 2180| | 2181| |/*-----------------------------------. 2182| || yyabortlab -- YYABORT comes here. | 2183| |`-----------------------------------*/ 2184| 1.52k|yyabortlab: 2185| 1.52k| yyresult = 1; 2186| 1.52k| goto yyreturn; 2187| | 2188| | 2189| 0|#if !defined yyoverflow || YYERROR_VERBOSE 2190| |/*-------------------------------------------------. 2191| || yyexhaustedlab -- memory exhaustion comes here. | 2192| |`-------------------------------------------------*/ 2193| 0|yyexhaustedlab: 2194| 0| yyerror (&yylloc, context, YY_("memory exhausted")); ------------------ | | 69| 0|#define yyerror igraph_dl_yyerror ------------------ yyerror (&yylloc, context, YY_("memory exhausted")); ------------------ | | 334| 0|# define YY_(Msgid) Msgid ------------------ 2195| 0| yyresult = 2; 2196| | /* Fall through. */ 2197| 0|#endif 2198| | 2199| | 2200| |/*-----------------------------------------------------. 2201| || yyreturn -- parsing is finished, return the result. | 2202| |`-----------------------------------------------------*/ 2203| 2.33k|yyreturn: 2204| 2.33k| if (yychar != YYEMPTY) ------------------ | | 780| 2.33k|#define YYEMPTY (-2) ------------------ | Branch (2204:7): [True: 814, False: 1.52k] ------------------ 2205| 814| { 2206| | /* Make sure we have latest lookahead translation. See comments at 2207| | user semantic actions for why this is necessary. */ 2208| 814| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 814| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 814|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 814, False: 0] | | | Branch (547:18): [True: 814, False: 0] | | ------------------ ------------------ 2209| 814| yydestruct ("Cleanup: discarding lookahead", 2210| 814| yytoken, &yylval, &yylloc, context); 2211| 814| } 2212| | /* Do not reclaim the symbols of the rule whose action triggered 2213| | this YYABORT or YYACCEPT. */ 2214| 2.33k| YYPOPSTACK (yylen); ------------------ | | 1361| 2.33k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2215| 2.33k| YY_STACK_PRINT (yyss, yyssp); 2216| 9.79k| while (yyssp != yyss) ------------------ | Branch (2216:10): [True: 7.45k, False: 2.33k] ------------------ 2217| 7.45k| { 2218| 7.45k| yydestruct ("Cleanup: popping", 2219| 7.45k| yystos[+*yyssp], yyvsp, yylsp, context); 2220| 7.45k| YYPOPSTACK (1); ------------------ | | 1361| 7.45k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2221| 7.45k| } 2222| 2.33k|#ifndef yyoverflow 2223| 2.33k| if (yyss != yyssa) ------------------ | Branch (2223:7): [True: 0, False: 2.33k] ------------------ 2224| 0| YYSTACK_FREE (yyss); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2225| 2.33k|#endif 2226| 2.33k|#if YYERROR_VERBOSE 2227| 2.33k| if (yymsg != yymsgbuf) ------------------ | Branch (2227:7): [True: 0, False: 2.33k] ------------------ 2228| 0| YYSTACK_FREE (yymsg); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2229| 2.33k|#endif 2230| 2.33k| return yyresult; 2231| 0|} igraph_dl_yyerror: 2237| 1.47k| const char *s) { 2238| 1.47k| snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1, 2239| 1.47k| "Parse error in DL file, line %i (%s)", 2240| 1.47k| locp->first_line, s); 2241| 1.47k| return 0; 2242| 1.47k|} dl-parser.c:yysyntax_error: 1131| 814|{ 1132| 814| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1133| | /* Internationalized format string. */ 1134| 814| const char *yyformat = YY_NULLPTR; ------------------ | | 138| 814|# define YY_NULLPTR ((void*)0) ------------------ 1135| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1136| | one per "expected"). */ 1137| 814| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1138| | /* Actual size of YYARG. */ 1139| 814| int yycount = 0; 1140| | /* Cumulated lengths of YYARG. */ 1141| 814| YYPTRDIFF_T yysize = 0; ------------------ | | 285| 814|# 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| 814| if (yytoken != YYEMPTY) ------------------ | | 780| 814|#define YYEMPTY (-2) ------------------ | Branch (1166:7): [True: 814, False: 0] ------------------ 1167| 814| { 1168| 814| int yyn = yypact[+*yyssp]; 1169| 814| YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 285| 814|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 138| 814|# define YY_NULLPTR ((void*)0) ------------------ 1170| 814| yysize = yysize0; 1171| 814| yyarg[yycount++] = yytname[yytoken]; 1172| 814| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 814| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 814|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (1172:11): [True: 814, False: 0] ------------------ 1173| 814| { 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| 814| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1177:26): [True: 0, False: 814] ------------------ 1178| | /* Stay within bounds of both yycheck and yytname. */ 1179| 814| int yychecklim = YYLAST - yyn + 1; ------------------ | | 529| 814|#define YYLAST 118 ------------------ 1180| 814| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 814|#define YYNTOKENS 17 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 814|#define YYNTOKENS 17 ------------------ | Branch (1180:24): [True: 0, False: 814] ------------------ 1181| 814| int yyx; 1182| | 1183| 14.5k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1183:32): [True: 13.7k, False: 801] ------------------ 1184| 13.7k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 808| 15.0k|#define YYTERROR 1 ------------------ | Branch (1184:17): [True: 1.32k, False: 12.4k] | Branch (1184:46): [True: 1.32k, False: 0] ------------------ 1185| 13.7k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 637| 0| 0 ------------------ | Branch (1185:20): [Folded - Ignored] ------------------ 1186| 1.32k| { 1187| 1.32k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1187:21): [True: 13, False: 1.31k] ------------------ 1188| 13| { 1189| 13| yycount = 1; 1190| 13| yysize = yysize0; 1191| 13| break; 1192| 13| } 1193| 1.31k| yyarg[yycount++] = yytname[yyx]; 1194| 1.31k| { 1195| 1.31k| YYPTRDIFF_T yysize1 ------------------ | | 285| 1.31k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1196| 1.31k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 138| 1.31k|# define YY_NULLPTR ((void*)0) ------------------ 1197| 1.31k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 1.31k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 1.31k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 2.62k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1197:23): [True: 1.31k, False: 0] | Branch (1197:44): [True: 1.31k, False: 0] ------------------ 1198| 1.31k| yysize = yysize1; 1199| 0| else 1200| 0| return 2; 1201| 1.31k| } 1202| 1.31k| } 1203| 814| } 1204| 814| } 1205| | 1206| 814| switch (yycount) 1207| 814| { 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: 814] ------------------ 1213| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1209| 0| case N: \ | | ------------------ | | | Branch (1209:7): [True: 0, False: 814] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1214| 13| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1209| 13| case N: \ | | ------------------ | | | Branch (1209:7): [True: 13, False: 801] | | ------------------ | | 1210| 13| yyformat = S; \ | | 1211| 13| break ------------------ 1215| 369| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1209| 369| case N: \ | | ------------------ | | | Branch (1209:7): [True: 369, False: 445] | | ------------------ | | 1210| 369| yyformat = S; \ | | 1211| 369| break ------------------ 1216| 407| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1209| 407| case N: \ | | ------------------ | | | Branch (1209:7): [True: 407, False: 407] | | ------------------ | | 1210| 407| yyformat = S; \ | | 1211| 407| break ------------------ 1217| 25| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1209| 25| case N: \ | | ------------------ | | | Branch (1209:7): [True: 25, False: 789] | | ------------------ | | 1210| 25| yyformat = S; \ | | 1211| 25| break ------------------ 1218| 814| 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: 814] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1219| 814|# undef YYCASE_ 1220| 814| } 1221| | 1222| 814| { 1223| | /* Don't count the "%s"s in the final size, but reserve room for 1224| | the terminator. */ 1225| 814| YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 285| 814|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 1035| 814|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 814|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1226| 814| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 814|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 814| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 1.62k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1226:9): [True: 814, False: 0] | Branch (1226:30): [True: 814, False: 0] ------------------ 1227| 814| yysize = yysize1; 1228| 0| else 1229| 0| return 2; 1230| 814| } 1231| | 1232| 814| if (*yymsg_alloc < yysize) ------------------ | Branch (1232:7): [True: 0, False: 814] ------------------ 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): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | 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): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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| 814| { 1245| 814| char *yyp = *yymsg; 1246| 814| int yyi = 0; 1247| 34.6k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1247:12): [True: 33.8k, False: 814] ------------------ 1248| 33.8k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1248:11): [True: 2.07k, False: 31.7k] | Branch (1248:26): [True: 2.07k, False: 0] | Branch (1248:48): [True: 2.07k, False: 0] ------------------ 1249| 2.07k| { 1250| 2.07k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1251| 2.07k| yyformat += 2; 1252| 2.07k| } 1253| 31.7k| else 1254| 31.7k| { 1255| 31.7k| ++yyp; 1256| 31.7k| ++yyformat; 1257| 31.7k| } 1258| 814| } 1259| 814| return 0; 1260| 814|} dl-parser.c:yytnamerr: 1079| 4.19k|{ 1080| 4.19k| if (*yystr == '"') ------------------ | Branch (1080:7): [True: 3.03k, False: 1.15k] ------------------ 1081| 3.03k| { 1082| 3.03k| YYPTRDIFF_T yyn = 0; ------------------ | | 285| 3.03k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1083| 3.03k| char const *yyp = yystr; 1084| | 1085| 3.03k| for (;;) 1086| 26.3k| switch (*++yyp) 1087| 26.3k| { 1088| 0| case '\'': ------------------ | Branch (1088:11): [True: 0, False: 26.3k] ------------------ 1089| 0| case ',': ------------------ | Branch (1089:11): [True: 0, False: 26.3k] ------------------ 1090| 0| goto do_not_strip_quotes; 1091| | 1092| 0| case '\\': ------------------ | Branch (1092:11): [True: 0, False: 26.3k] ------------------ 1093| 0| if (*++yyp != '\\') ------------------ | Branch (1093:17): [True: 0, False: 0] ------------------ 1094| 0| goto do_not_strip_quotes; 1095| 0| else 1096| 0| goto append; 1097| | 1098| 0| append: 1099| 23.2k| default: ------------------ | Branch (1099:11): [True: 23.2k, False: 3.03k] ------------------ 1100| 23.2k| if (yyres) ------------------ | Branch (1100:17): [True: 11.4k, False: 11.8k] ------------------ 1101| 11.4k| yyres[yyn] = *yyp; 1102| 23.2k| yyn++; 1103| 23.2k| break; 1104| | 1105| 3.03k| case '"': ------------------ | Branch (1105:11): [True: 3.03k, False: 23.2k] ------------------ 1106| 3.03k| if (yyres) ------------------ | Branch (1106:17): [True: 1.50k, False: 1.53k] ------------------ 1107| 1.50k| yyres[yyn] = '\0'; 1108| 3.03k| return yyn; 1109| 26.3k| } 1110| 0| do_not_strip_quotes: ; 1111| 0| } 1112| | 1113| 1.15k| if (yyres) ------------------ | Branch (1113:7): [True: 572, False: 585] ------------------ 1114| 572| return yystpcpy (yyres, yystr) - yyres; 1115| 585| else 1116| 585| return yystrlen (yystr); ------------------ | | 1035| 585|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 585|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1117| 1.15k|} dl-parser.c:yystpcpy: 1057| 572|{ 1058| 572| char *yyd = yydest; 1059| 572| const char *yys = yysrc; 1060| | 1061| 2.99k| while ((*yyd++ = *yys++) != '\0') ------------------ | Branch (1061:10): [True: 2.42k, False: 572] ------------------ 1062| 2.42k| continue; 1063| | 1064| 572| return yyd - 1; 1065| 572|} dl-parser.c:yydestruct: 1269| 15.5k|{ 1270| 15.5k| YYUSE (yyvaluep); ------------------ | | 356| 15.5k|# define YYUSE(E) ((void) (E)) ------------------ 1271| 15.5k| YYUSE (yylocationp); ------------------ | | 356| 15.5k|# define YYUSE(E) ((void) (E)) ------------------ 1272| 15.5k| YYUSE (context); ------------------ | | 356| 15.5k|# define YYUSE(E) ((void) (E)) ------------------ 1273| 15.5k| if (!yymsg) ------------------ | Branch (1273:7): [True: 0, False: 15.5k] ------------------ 1274| 0| yymsg = "Deleting"; 1275| 15.5k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1276| | 1277| 15.5k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1278| 15.5k| YYUSE (yytype); ------------------ | | 356| 15.5k|# define YYUSE(E) ((void) (E)) ------------------ 1279| 15.5k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1280| 15.5k|} dl-parser.c:igraph_i_dl_add_str: 2245| 1.60M| igraph_i_dl_parsedata_t *context) { 2246| 1.60M| IGRAPH_CHECK(igraph_strvector_push_back_len(&context->labels, newstr, length)); ------------------ | | 648| 1.60M| do { \ | | 649| 1.60M| igraph_error_t igraph_i_ret = (expr); \ | | 650| 1.60M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 1.60M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.60M] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 1.60M| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 2247| 1.60M| return IGRAPH_SUCCESS; 2248| 1.60M|} dl-parser.c:igraph_i_dl_add_edge: 2251| 2.18M| 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.18M| IGRAPH_CHECK(igraph_vector_int_push_back(&context->edges, from)); ------------------ | | 648| 2.18M| do { \ | | 649| 2.18M| igraph_error_t igraph_i_ret = (expr); \ | | 650| 2.18M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 2.18M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.18M] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 2.18M| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 2255| 2.18M| IGRAPH_CHECK(igraph_vector_int_push_back(&context->edges, to)); ------------------ | | 648| 2.18M| do { \ | | 649| 2.18M| igraph_error_t igraph_i_ret = (expr); \ | | 650| 2.18M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 2.18M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.18M] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 2.18M| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 2256| 2.18M| return IGRAPH_SUCCESS; 2257| 2.18M|} dl-parser.c:igraph_i_dl_add_edge_w: 2261| 317k| igraph_i_dl_parsedata_t *context) { 2262| 317k| igraph_integer_t n=igraph_vector_size(&context->weights); 2263| 317k| igraph_integer_t n2=igraph_vector_int_size(&context->edges)/2; 2264| 317k| if (n != n2) { ------------------ | Branch (2264:7): [True: 226k, False: 91.0k] ------------------ 2265| 226k| IGRAPH_CHECK(igraph_vector_resize(&context->weights, n2)); ------------------ | | 648| 226k| do { \ | | 649| 226k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 226k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 226k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 226k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 226k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 2266| 2.08M| for (; nweights)[n]=IGRAPH_NAN; ------------------ | | 65| 1.85M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context->weights)[n]=IGRAPH_NAN; ------------------ | | 143| 1.85M|#define IGRAPH_NAN ((double)NAN) ------------------ 2268| 1.85M| } 2269| 226k| } 2270| 317k| IGRAPH_CHECK(igraph_i_dl_add_edge(from, to, context)); ------------------ | | 648| 317k| do { \ | | 649| 317k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 317k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 317k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 2271| 317k| IGRAPH_CHECK(igraph_vector_push_back(&context->weights, weight)); ------------------ | | 648| 317k| do { \ | | 649| 317k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 317k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 317k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 2272| 317k| return IGRAPH_SUCCESS; 2273| 317k|} dl-parser.c:igraph_i_dl_check_vid: 2277| 5.91M|static igraph_error_t igraph_i_dl_check_vid(igraph_integer_t dl_vid) { 2278| 5.91M| if (dl_vid < 1) { ------------------ | Branch (2278:9): [True: 314, False: 5.91M] ------------------ 2279| 314| IGRAPH_ERRORF("Invalid vertex index in DL file: %" IGRAPH_PRId ".", ------------------ | | 469| 314| do { \ | | 470| 314| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 314| igraph_errno, __VA_ARGS__) ; \ | | 472| 314| return igraph_errno; \ | | 473| 314| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 2280| 314| IGRAPH_EINVAL, dl_vid); 2281| 314| } 2282| 5.91M| if (dl_vid > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 5.91M|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (2282:9): [True: 288, False: 5.91M] ------------------ 2283| 288| IGRAPH_ERRORF("Vertex index too large in DL file: %" IGRAPH_PRId ".", ------------------ | | 469| 288| do { \ | | 470| 288| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 288| igraph_errno, __VA_ARGS__) ; \ | | 472| 288| return igraph_errno; \ | | 473| 288| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 2284| 288| IGRAPH_EINVAL, dl_vid); 2285| 288| } 2286| 5.91M| return IGRAPH_SUCCESS; 2287| 5.91M|} LLVMFuzzerTestOneInput: 25| 2.33k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 26| | 27| 2.33k| igraph_set_error_handler(igraph_error_handler_ignore); 28| 2.33k| igraph_set_warning_handler(igraph_warning_handler_ignore); 29| | 30| | // Turn on attribute handling 31| 2.33k| igraph_set_attribute_table(&igraph_cattribute_table); 32| | 33| | // Read input file 34| 2.33k| FILE *ifile = fmemopen((void*) data, size, "r"); 35| 2.33k| if (!ifile) { ------------------ | Branch (35:9): [True: 0, False: 2.33k] ------------------ 36| 0| return 0; 37| 0| } 38| | 39| | // Do the fuzzing 40| 2.33k| igraph_t g; 41| 2.33k| if (igraph_read_graph_dl(&g, ifile, IGRAPH_DIRECTED) == IGRAPH_SUCCESS) { ------------------ | Branch (41:9): [True: 445, False: 1.89k] ------------------ 42| | // Clean up 43| 445| igraph_destroy(&g); 44| 445| } 45| | 46| | // no need to call igraph_destroy() if igraph_read_graph_dl() returns an 47| | // error code as we don't have a valid graph object in that case 48| | 49| 2.33k| fclose(ifile); 50| | 51| 2.33k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY); ------------------ | | 916| 2.33k| do { \ | | 917| 2.33k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | ------------------ | | | | 406| 0|# define IGRAPH_FILE_BASENAME __FILE__ | | ------------------ | | 919| 0| } \ | | 920| 2.33k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 52| | 53| 2.33k| return 0; 54| 2.33k|} igraph_error: 211| 3.11k| igraph_error_t igraph_errno) { 212| | 213| 3.11k| if (igraph_i_error_handler) { ------------------ | Branch (213:9): [True: 3.11k, False: 0] ------------------ 214| 3.11k| igraph_i_error_handler(reason, file, line, igraph_errno); 215| 3.11k|#ifndef USING_R 216| 3.11k| } else { 217| 0| igraph_error_handler_abort(reason, file, line, igraph_errno); 218| 0|#endif 219| 0| } 220| 3.11k| return igraph_errno; 221| 3.11k|} igraph_errorf: 240| 652| igraph_error_t igraph_errno, ...) { 241| 652| va_list ap; 242| 652| va_start(ap, igraph_errno); 243| 652| vsnprintf(igraph_i_errormsg_buffer, 244| 652| sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap); 245| 652| va_end(ap); 246| 652| return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno); 247| 652|} igraph_error_handler_ignore: 266| 3.11k| int line, igraph_error_t igraph_errno) { 267| 3.11k| IGRAPH_UNUSED(reason); ------------------ | | 32| 3.11k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 268| 3.11k| IGRAPH_UNUSED(file); ------------------ | | 32| 3.11k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 269| 3.11k| IGRAPH_UNUSED(line); ------------------ | | 32| 3.11k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 270| 3.11k| IGRAPH_UNUSED(igraph_errno); ------------------ | | 32| 3.11k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 271| | 272| 3.11k| IGRAPH_FINALLY_FREE(); 273| 3.11k|} igraph_set_error_handler: 298| 2.33k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) { 299| 2.33k| igraph_error_handler_t *previous_handler = igraph_i_error_handler; 300| 2.33k| igraph_i_error_handler = new_handler; 301| 2.33k| return previous_handler; 302| 2.33k|} IGRAPH_FINALLY_REAL: 320| 82.0k|void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) { 321| 82.0k| int no = igraph_i_finally_stack_size; 322| 82.0k| if (no < 0) { ------------------ | Branch (322:9): [True: 0, False: 82.0k] ------------------ 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); ------------------ | | 867| 0| do { \ | | 868| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 869| 0| __VA_ARGS__); \ | | 870| 0| } while (0) | | ------------------ | | | Branch (870:14): [Folded - Ignored] | | ------------------ ------------------ 326| 0| } 327| 82.0k| if (no >= (int) (sizeof(igraph_i_finally_stack) / sizeof(igraph_i_finally_stack[0]))) { ------------------ | Branch (327:9): [True: 0, False: 82.0k] ------------------ 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); ------------------ | | 867| 0| do { \ | | 868| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 869| 0| __VA_ARGS__); \ | | 870| 0| } while (0) | | ------------------ | | | Branch (870:14): [Folded - Ignored] | | ------------------ ------------------ 331| 0| } 332| 82.0k| igraph_i_finally_stack[no].ptr = ptr; 333| 82.0k| igraph_i_finally_stack[no].func = func; 334| 82.0k| igraph_i_finally_stack[no].level = igraph_i_finally_stack_level; 335| 82.0k| igraph_i_finally_stack_size++; 336| 82.0k|} IGRAPH_FINALLY_CLEAN: 338| 24.6k|void IGRAPH_FINALLY_CLEAN(int minus) { 339| 24.6k| igraph_i_finally_stack_size -= minus; 340| 24.6k| if (igraph_i_finally_stack_size < 0) { ------------------ | Branch (340:9): [True: 0, False: 24.6k] ------------------ 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); ------------------ | | 867| 0| do { \ | | 868| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 869| 0| __VA_ARGS__); \ | | 870| 0| } while (0) | | ------------------ | | | Branch (870:14): [Folded - Ignored] | | ------------------ ------------------ 345| 0| } 346| 24.6k|} IGRAPH_FINALLY_FREE: 348| 3.11k|void IGRAPH_FINALLY_FREE(void) { 349| 13.1k| for (; igraph_i_finally_stack_size > 0; igraph_i_finally_stack_size--) { ------------------ | Branch (349:12): [True: 10.9k, False: 2.25k] ------------------ 350| 10.9k| int p = igraph_i_finally_stack_size - 1; 351| | /* Call destructors only up to the current level */ 352| 10.9k| if (igraph_i_finally_stack[p].level < igraph_i_finally_stack_level) { ------------------ | Branch (352:13): [True: 851, False: 10.0k] ------------------ 353| 851| break; 354| 851| } 355| 10.0k| igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr); 356| 10.0k| } 357| 3.11k|} IGRAPH_FINALLY_STACK_SIZE: 359| 2.33k|int IGRAPH_FINALLY_STACK_SIZE(void) { 360| 2.33k| return igraph_i_finally_stack_size; 361| 2.33k|} IGRAPH_FINALLY_ENTER: 377| 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."); ------------------ | | 887| 0| do { \ | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 889| 0| } while (0) | | ------------------ | | | Branch (889:14): [Folded - Ignored] | | ------------------ ------------------ 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."); ------------------ | | 887| 0| do { \ | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 889| 0| } while (0) | | ------------------ | | | Branch (889:14): [Folded - Ignored] | | ------------------ ------------------ 405| 0| } 406| 555k|} igraph_warning_handler_ignore: 426| 346|void igraph_warning_handler_ignore(const char *reason, const char *file, int line) { 427| 346| IGRAPH_UNUSED(reason); ------------------ | | 32| 346|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 428| 346| IGRAPH_UNUSED(file); ------------------ | | 32| 346|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 429| 346| IGRAPH_UNUSED(line); ------------------ | | 32| 346|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 430| 346|} igraph_warning: 470| 346|void igraph_warning(const char *reason, const char *file, int line) { 471| | 472| 346| if (igraph_i_warning_handler) { ------------------ | Branch (472:9): [True: 346, False: 0] ------------------ 473| 346| igraph_i_warning_handler(reason, file, line); 474| 346|#ifndef USING_R 475| 346| } else { 476| 0| igraph_warning_handler_print(reason, file, line); 477| 0|#endif 478| 0| } 479| 346|} igraph_set_warning_handler: 523| 2.33k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) { 524| 2.33k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler; 525| 2.33k| igraph_i_warning_handler = new_handler; 526| 2.33k| return previous_handler; 527| 2.33k|} igraph_free: 62| 1.36k|void igraph_free(void *ptr) { 63| 1.36k| IGRAPH_FREE(ptr); ------------------ | | 41| 1.36k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 64| 1.36k|} igraph_strvector_init: 72| 15.3k|igraph_error_t igraph_strvector_init(igraph_strvector_t *sv, igraph_integer_t size) { 73| | 74| 15.3k| sv->stor_begin = IGRAPH_CALLOC(size, const char *); ------------------ | | 38| 15.3k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 30.7k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 15.3k, False: 0] | | | | | Branch (36:24): [True: 15.3k, False: 0] | | | | | Branch (36:66): [True: 8.01k, False: 7.35k] | | | | ------------------ | | ------------------ ------------------ 75| 15.3k| IGRAPH_CHECK_OOM(sv->stor_begin, "Cannot initialize string vector."); ------------------ | | 701| 15.3k| do { \ | | 702| 15.3k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 15.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 15.3k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 15.3k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 76| | 77| 15.3k| sv->stor_end = sv->stor_begin + size; 78| 15.3k| sv->end = sv->stor_end; 79| | 80| 15.3k| return IGRAPH_SUCCESS; 81| 15.3k|} igraph_strvector_destroy: 96| 15.3k|void igraph_strvector_destroy(igraph_strvector_t *sv) { 97| 15.3k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 916| 15.3k| do { \ | | 917| 15.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 15.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 15.3k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 15.3k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 98| 15.3k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 916| 15.3k| do { \ | | 917| 15.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 15.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 15.3k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 15.3k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 99| 2.17M| for (const char **ptr = sv->stor_begin; ptr < sv->end; ptr++) { ------------------ | Branch (99:45): [True: 2.16M, False: 15.3k] ------------------ 100| 2.16M| IGRAPH_FREE(*ptr); ------------------ | | 41| 2.16M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 101| 2.16M| } 102| 15.3k| IGRAPH_FREE(sv->stor_begin); ------------------ | | 41| 15.3k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 103| 15.3k|} igraph_strvector_get: 118| 7.06M|const char *igraph_strvector_get(const igraph_strvector_t *sv, igraph_integer_t idx) { 119| 7.06M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 916| 7.06M| do { \ | | 917| 7.06M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 7.06M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 7.06M] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 7.06M| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 120| 7.06M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 916| 7.06M| do { \ | | 917| 7.06M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 7.06M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 7.06M] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 7.06M| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 121| 7.06M| return sv->stor_begin[idx] ? sv->stor_begin[idx] : ""; ------------------ | Branch (121:12): [True: 7.06M, False: 0] ------------------ 122| 7.06M|} igraph_strvector_set: 142| 18.3k| const char *value) { 143| 18.3k| return igraph_strvector_set_len(sv, idx, value, strlen(value)); 144| 18.3k|} igraph_strvector_set_len: 164| 18.3k| const char *value, size_t len) { 165| 18.3k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 916| 18.3k| do { \ | | 917| 18.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 18.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 18.3k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 18.3k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 166| 18.3k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 916| 18.3k| do { \ | | 917| 18.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 18.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 18.3k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 18.3k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 167| | 168| 18.3k| if (sv->stor_begin[idx] == NULL) { ------------------ | Branch (168:9): [True: 11.6k, False: 6.73k] ------------------ 169| 11.6k| sv->stor_begin[idx] = strndup(value, len); 170| 11.6k| IGRAPH_CHECK_OOM(sv->stor_begin[idx], "Cannot reserve space for new item in string vector."); ------------------ | | 701| 11.6k| do { \ | | 702| 11.6k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 11.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 11.6k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 11.6k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 171| 11.6k| } else { 172| 6.73k| char *tmp = IGRAPH_REALLOC(sv->stor_begin[idx], len + 1, char); ------------------ | | 40| 6.73k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 36| 13.4k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 6.73k, False: 0] | | | | | Branch (36:24): [True: 6.73k, False: 0] | | | | | Branch (36:66): [True: 6.73k, False: 0] | | | | ------------------ | | ------------------ ------------------ 173| 6.73k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new item in string vector."); ------------------ | | 701| 6.73k| do { \ | | 702| 6.73k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 6.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 6.73k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 6.73k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 174| | 175| 6.73k| memcpy(tmp, value, len * sizeof(char)); 176| 6.73k| tmp[len] = '\0'; 177| 6.73k| sv->stor_begin[idx] = tmp; 178| 6.73k| } 179| | 180| 18.3k| return IGRAPH_SUCCESS; 181| 18.3k|} igraph_strvector_append: 301| 204| const igraph_strvector_t *from) { 302| 204| const igraph_integer_t to_size = igraph_strvector_size(to); 303| 204| const igraph_integer_t from_size = igraph_strvector_size(from); 304| 204| const igraph_integer_t to_capacity = igraph_strvector_capacity(to); 305| 204| igraph_integer_t new_to_size; 306| 204| igraph_bool_t error = false; 307| 204| const char *tmp; 308| | 309| 204| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size); ------------------ | | 47| 204| do { \ | | 48| 204| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 204| igraph_integer_t _safe_sum; \ | | 50| 204| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 204] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 469| 0| do { \ | | | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 472| 0| return igraph_errno; \ | | | | 473| 0| } while (0) | | | | ------------------ | | | | | Branch (473:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 204| *(res) = _safe_sum; \ | | 54| 204| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 310| | 311| 204| if (to_capacity < new_to_size) { ------------------ | Branch (311:9): [True: 204, False: 0] ------------------ 312| 204| igraph_integer_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 204|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 204|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (312:44): [True: 204, False: 0] ------------------ 313| 204| if (new_to_capacity < new_to_size) { ------------------ | Branch (313:13): [True: 204, False: 0] ------------------ 314| 204| new_to_capacity = new_to_size; 315| 204| } 316| 204| IGRAPH_CHECK(igraph_strvector_reserve(to, new_to_capacity)); ------------------ | | 648| 204| do { \ | | 649| 204| igraph_error_t igraph_i_ret = (expr); \ | | 650| 204| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 204| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 204] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 204| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 317| 204| } 318| | 319| 1.05M| for (igraph_integer_t i = 0; i < from_size; i++) { ------------------ | Branch (319:34): [True: 1.05M, False: 204] ------------------ 320| 1.05M| if (from->stor_begin[i] == NULL || from->stor_begin[i][0] == '\0') { ------------------ | Branch (320:13): [True: 0, False: 1.05M] | Branch (320:44): [True: 0, False: 1.05M] ------------------ 321| | /* Represent empty strings as NULL. */ 322| 0| tmp = NULL; 323| 1.05M| } else { 324| 1.05M| tmp = strdup(from->stor_begin[i]); 325| 1.05M| if (tmp == NULL) { ------------------ | Branch (325:17): [True: 0, False: 1.05M] ------------------ 326| 0| error = true; 327| 0| break; 328| 0| } 329| 1.05M| } 330| 1.05M| *(to->end) = tmp; 331| 1.05M| to->end++; 332| 1.05M| } 333| | 334| 204| if (error) { ------------------ | Branch (334:9): [True: 0, False: 204] ------------------ 335| 0| igraph_strvector_resize(to, to_size); /* always shrinks */ 336| 0| IGRAPH_ERROR("Cannot append string vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 337| 0| } 338| | 339| 204| return IGRAPH_SUCCESS; 340| 204|} igraph_strvector_clear: 394| 326|void igraph_strvector_clear(igraph_strvector_t *sv) { 395| 326| igraph_integer_t n = igraph_strvector_size(sv); 396| | 397| 543k| for (igraph_integer_t i = 0; i < n; i++) { ------------------ | Branch (397:34): [True: 543k, False: 326] ------------------ 398| 543k| IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 41| 543k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 399| 543k| } 400| 326| sv->end = sv->stor_begin; 401| 326|} igraph_strvector_resize: 420| 530k|igraph_error_t igraph_strvector_resize(igraph_strvector_t *sv, igraph_integer_t newsize) { 421| 530k| igraph_integer_t toadd = newsize - igraph_strvector_size(sv); 422| 530k| igraph_integer_t oldsize = igraph_strvector_size(sv); 423| | 424| 530k| if (newsize < oldsize) { ------------------ | Branch (424:9): [True: 530k, False: 138] ------------------ 425| 1.06M| for (igraph_integer_t i = newsize; i < oldsize; i++) { ------------------ | Branch (425:44): [True: 530k, False: 530k] ------------------ 426| 530k| IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 41| 530k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 427| 530k| } 428| 530k| sv->end = sv->stor_begin + newsize; 429| 530k| } else if (newsize > oldsize) { ------------------ | Branch (429:16): [True: 0, False: 138] ------------------ 430| 0| IGRAPH_CHECK(igraph_strvector_reserve(sv, newsize)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 431| 0| memset(sv->stor_begin + oldsize, 0, toadd * sizeof(const char *)); 432| 0| sv->end = sv->stor_begin + newsize; 433| 0| } 434| | 435| 530k| return IGRAPH_SUCCESS; 436| 530k|} igraph_strvector_capacity: 449| 8.48k|igraph_integer_t igraph_strvector_capacity(const igraph_strvector_t *sv) { 450| 8.48k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 916| 8.48k| do { \ | | 917| 8.48k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 8.48k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 8.48k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 8.48k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 451| 8.48k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 916| 8.48k| do { \ | | 917| 8.48k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 8.48k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 8.48k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 8.48k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 452| 8.48k| return sv->stor_end - sv->stor_begin; 453| 8.48k|} igraph_strvector_reserve: 482| 8.28k|igraph_error_t igraph_strvector_reserve(igraph_strvector_t *sv, igraph_integer_t capacity) { 483| 8.28k| igraph_integer_t current_capacity = igraph_strvector_capacity(sv); 484| | 485| 8.28k| if (capacity <= current_capacity) { ------------------ | Branch (485:9): [True: 0, False: 8.28k] ------------------ 486| 0| return IGRAPH_SUCCESS; 487| 0| } 488| | 489| 8.28k| const char **tmp = IGRAPH_REALLOC(sv->stor_begin, capacity, const char *); ------------------ | | 40| 8.28k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 36| 16.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 8.28k, False: 0] | | | | | Branch (36:24): [True: 8.28k, False: 0] | | | | | Branch (36:66): [True: 8.28k, False: 0] | | | | ------------------ | | ------------------ ------------------ 490| 8.28k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new items in string vector."); ------------------ | | 701| 8.28k| do { \ | | 702| 8.28k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 8.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 8.28k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 8.28k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 491| | 492| 8.28k| sv->end = tmp + (sv->end - sv->stor_begin); 493| 8.28k| sv->stor_begin = tmp; 494| 8.28k| sv->stor_end = sv->stor_begin + capacity; 495| | 496| 8.28k| return IGRAPH_SUCCESS; 497| 8.28k|} igraph_strvector_size: 539| 2.17M|igraph_integer_t igraph_strvector_size(const igraph_strvector_t *sv) { 540| 2.17M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 916| 2.17M| do { \ | | 917| 2.17M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.17M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.17M] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.17M| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 541| 2.17M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 916| 2.17M| do { \ | | 917| 2.17M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.17M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.17M] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.17M| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 542| 2.17M| return sv->end - sv->stor_begin; 543| 2.17M|} igraph_strvector_push_back: 581| 562k|igraph_error_t igraph_strvector_push_back(igraph_strvector_t *sv, const char *value) { 582| 562k| IGRAPH_CHECK(igraph_i_strvector_expand_if_full(sv)); ------------------ | | 648| 562k| do { \ | | 649| 562k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 562k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 562k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 562k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 562k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 583| 562k| const char *tmp = strdup(value); 584| 562k| IGRAPH_CHECK_OOM(tmp, "Cannot push new string to string vector."); ------------------ | | 701| 562k| do { \ | | 702| 562k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 562k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 562k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 562k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 585| 562k| *sv->end = tmp; 586| 562k| sv->end++; 587| | 588| 562k| return IGRAPH_SUCCESS; 589| 562k|} igraph_strvector_push_back_len: 607| 1.60M| const char *value, igraph_integer_t len) { 608| | 609| 1.60M| IGRAPH_CHECK(igraph_i_strvector_expand_if_full(sv)); ------------------ | | 648| 1.60M| do { \ | | 649| 1.60M| igraph_error_t igraph_i_ret = (expr); \ | | 650| 1.60M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 1.60M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.60M] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 1.60M| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 610| 1.60M| const char *tmp = strndup(value, len); 611| 1.60M| if (! tmp) { ------------------ | Branch (611:9): [True: 0, False: 1.60M] ------------------ 612| 0| IGRAPH_ERROR("Cannot add string to string vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 613| 0| } 614| 1.60M| *sv->end = tmp; 615| 1.60M| sv->end++; 616| | 617| 1.60M| return IGRAPH_SUCCESS; 618| 1.60M|} igraph_strvector_update: 701| 171|) { 702| 171| igraph_strvector_clear(to); 703| 171| IGRAPH_CHECK(igraph_strvector_append(to, from)); ------------------ | | 648| 171| do { \ | | 649| 171| igraph_error_t igraph_i_ret = (expr); \ | | 650| 171| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 171| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 171] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 171| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 704| 171| return IGRAPH_SUCCESS; 705| 171|} strvector.c:igraph_i_strvector_expand_if_full: 549| 2.16M|static igraph_error_t igraph_i_strvector_expand_if_full(igraph_strvector_t *sv) { 550| 2.16M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 916| 2.16M| do { \ | | 917| 2.16M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.16M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.16M] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.16M| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 551| 2.16M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 916| 2.16M| do { \ | | 917| 2.16M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.16M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.16M] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.16M| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 552| | 553| 2.16M| if (sv->stor_end == sv->end) { ------------------ | Branch (553:9): [True: 8.07k, False: 2.15M] ------------------ 554| 8.07k| igraph_integer_t old_size = igraph_strvector_size(sv); 555| 8.07k| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 8.07k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 8.07k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (555:37): [True: 8.07k, False: 0] ------------------ 556| 8.07k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 77| 8.07k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (556:13): [True: 0, False: 8.07k] ------------------ 557| 0| IGRAPH_ERROR("Cannot add new item to string vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 558| 0| } 559| 8.07k| if (new_size == 0) { ------------------ | Branch (559:13): [True: 1.05k, False: 7.01k] ------------------ 560| 1.05k| new_size = 1; 561| 1.05k| } 562| 8.07k| IGRAPH_CHECK(igraph_strvector_reserve(sv, new_size)); ------------------ | | 648| 8.07k| do { \ | | 649| 8.07k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 8.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 8.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 8.07k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 8.07k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 563| 8.07k| } 564| | 565| 2.16M| return IGRAPH_SUCCESS; 566| 2.16M|} igraph_trie_init: 62| 2.33k|igraph_error_t igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) { 63| 2.33k| t->maxvalue = -1; 64| 2.33k| t->storekeys = storekeys; 65| 2.33k| IGRAPH_CHECK(igraph_i_trie_init_node(&t->node)); ------------------ | | 648| 2.33k| do { \ | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 2.33k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 66| 2.33k| IGRAPH_FINALLY(igraph_i_trie_destroy_node, &t->node); ------------------ | | 591| 2.33k| do { \ | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | 595| 2.33k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 2.33k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 67| 2.33k| if (storekeys) { ------------------ | Branch (67:9): [True: 2.33k, False: 0] ------------------ 68| 2.33k| IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0)); ------------------ | | 648| 2.33k| do { \ | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 2.33k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 69| 2.33k| } 70| | 71| 2.33k| IGRAPH_FINALLY_CLEAN(1); 72| 2.33k| return IGRAPH_SUCCESS; 73| 2.33k|} igraph_trie_destroy: 103| 2.33k|void igraph_trie_destroy(igraph_trie_t *t) { 104| 2.33k| if (t->storekeys) { ------------------ | Branch (104:9): [True: 2.33k, False: 0] ------------------ 105| 2.33k| igraph_strvector_destroy(&t->keys); 106| 2.33k| } 107| 2.33k| igraph_i_trie_destroy_node(&t->node); 108| 2.33k|} igraph_trie_get: 299| 550k|igraph_error_t igraph_trie_get(igraph_trie_t *t, const char *key, igraph_integer_t *id) { 300| 550k| assert(key != NULL); 301| | 302| 550k| if (*key == '\0') { ------------------ | Branch (302:9): [True: 0, False: 550k] ------------------ 303| 0| IGRAPH_ERROR("Keys in a trie cannot be empty.", IGRAPH_EINVAL); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 304| 0| } 305| | 306| 550k| if (!t->storekeys) { ------------------ | Branch (306:9): [True: 0, False: 550k] ------------------ 307| 0| IGRAPH_CHECK(igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 308| 0| if (*id > t->maxvalue) { ------------------ | Branch (308:13): [True: 0, False: 0] ------------------ 309| 0| t->maxvalue = *id; 310| 0| } 311| 550k| } else { 312| 550k| igraph_error_t ret; 313| | 314| 550k| IGRAPH_FINALLY_ENTER(); 315| | /* Add it to the string vector first, we can undo this later */ 316| 550k| ret = igraph_strvector_push_back(&t->keys, key); 317| 550k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (317:13): [True: 0, False: 550k] ------------------ 318| 0| IGRAPH_FINALLY_EXIT(); 319| 0| IGRAPH_ERROR("Cannot get element from trie.", ret); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 320| 0| } 321| 550k| ret = igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id); 322| 550k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (322:13): [True: 0, False: 550k] ------------------ 323| 0| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */ 324| 0| IGRAPH_FINALLY_EXIT(); 325| 0| IGRAPH_ERROR("Cannot get element from trie.", ret); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 326| 0| } 327| | 328| | /* everything is fine */ 329| 550k| if (*id > t->maxvalue) { ------------------ | Branch (329:13): [True: 20.1k, False: 530k] ------------------ 330| 20.1k| t->maxvalue = *id; 331| 530k| } else { 332| 530k| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */ 333| 530k| } 334| 550k| IGRAPH_FINALLY_EXIT(); 335| 550k| } 336| | 337| 550k| return IGRAPH_SUCCESS; 338| 550k|} igraph_trie_get_len: 358| 7.28k| igraph_integer_t *id) { 359| | 360| 7.28k| char *tmp = strndup(key, length); 361| 7.28k| IGRAPH_CHECK_OOM(tmp, "Cannot get from trie."); ------------------ | | 701| 7.28k| do { \ | | 702| 7.28k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 7.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 7.28k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 7.28k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 362| 7.28k| IGRAPH_FINALLY(igraph_free, tmp); ------------------ | | 591| 7.28k| do { \ | | 592| 7.28k| /* the following branch makes the compiler check the compatibility of \ | | 593| 7.28k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 7.28k| * incorrect destructor function with the pointer */ \ | | 595| 7.28k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 7.28k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 7.28k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 363| 7.28k| IGRAPH_CHECK(igraph_trie_get(t, tmp, id)); ------------------ | | 648| 7.28k| do { \ | | 649| 7.28k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 7.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 7.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 7.28k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 7.28k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 364| 7.28k| IGRAPH_FREE(tmp); ------------------ | | 41| 7.28k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 365| 7.28k| IGRAPH_FINALLY_CLEAN(1); 366| | 367| 7.28k| return IGRAPH_SUCCESS; 368| 7.28k|} igraph_trie_size: 414| 717|igraph_integer_t igraph_trie_size(igraph_trie_t *t) { 415| 717| return t->maxvalue + 1; 416| 717|} igraph_i_trie_borrow_keys: 433| 77|const igraph_strvector_t* igraph_i_trie_borrow_keys(igraph_trie_t *t) { 434| 77| return &t->keys; 435| 77|} trie.c:igraph_i_trie_init_node: 42| 2.33k|static igraph_error_t igraph_i_trie_init_node(igraph_trie_node_t *t) { 43| 2.33k| IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0); ------------------ | | 67| 2.33k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 648| 2.33k| do { \ | | | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 2.33k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 591| 2.33k| do { \ | | | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 595| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (68:65): [Folded - Ignored] | | ------------------ ------------------ 44| 2.33k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0); ------------------ | | 51| 2.33k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 648| 2.33k| do { \ | | | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 2.33k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 591| 2.33k| do { \ | | | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 595| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (52:65): [Folded - Ignored] | | ------------------ ------------------ 45| 2.33k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->values, 0); ------------------ | | 124| 2.33k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 2.33k| do { \ | | | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 2.33k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 2.33k| do { \ | | | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 595| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 46| 2.33k| IGRAPH_FINALLY_CLEAN(3); 47| 2.33k| return IGRAPH_SUCCESS; 48| 2.33k|} trie.c:igraph_i_trie_destroy_node: 92| 2.33k|static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) { 93| 2.33k| igraph_i_trie_destroy_node_helper(t, false); 94| 2.33k|} trie.c:igraph_i_trie_destroy_node_helper: 75| 10.3k|static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) { 76| 10.3k| igraph_strvector_destroy(&t->strs); 77| 10.3k| igraph_integer_t children_size = igraph_vector_ptr_size(&t->children); 78| 33.6k| for (igraph_integer_t i = 0; i < children_size; i++) { ------------------ | Branch (78:34): [True: 23.3k, False: 10.3k] ------------------ 79| 23.3k| igraph_trie_node_t *child = VECTOR(t->children)[i]; ------------------ | | 65| 23.3k|#define VECTOR(v) ((v).stor_begin) ------------------ 80| 23.3k| if (child != NULL) { ------------------ | Branch (80:13): [True: 8.01k, False: 15.3k] ------------------ 81| 8.01k| igraph_i_trie_destroy_node_helper(child, true); 82| 8.01k| } 83| 23.3k| } 84| 10.3k| igraph_vector_ptr_destroy(&t->children); 85| 10.3k| igraph_vector_int_destroy(&t->values); 86| 10.3k| if (sfree) { ------------------ | Branch (86:9): [True: 8.01k, False: 2.33k] ------------------ 87| 8.01k| IGRAPH_FREE(t); ------------------ | | 41| 8.01k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 88| 8.01k| } 89| 10.3k|} trie.c:igraph_i_trie_get_node: 130| 1.09M|) { 131| 1.09M| assert(key != NULL); 132| | 133| | /* If newvalue is negative, we don't add the node if nonexistent, only check 134| | * for its existence */ 135| 1.09M| igraph_bool_t add = (newvalue >= 0); 136| | 137| 1.09M| igraph_integer_t strs_size = igraph_strvector_size(&t->strs); 138| 6.53M| for (igraph_integer_t i = 0; i < strs_size; i++) { ------------------ | Branch (138:34): [True: 6.52M, False: 11.6k] ------------------ 139| 6.52M| size_t diff; 140| 6.52M| const char *str = igraph_strvector_get(&t->strs, i); 141| 6.52M| diff = igraph_i_strdiff(str, key); 142| | 143| 6.52M| if (diff == 0) { ------------------ | Branch (143:13): [True: 5.43M, False: 1.08M] ------------------ 144| | 145| | /* ------------------------------------ */ 146| | /* No match, next */ 147| | 148| 5.43M| } else if (str[diff] == '\0' && key[diff] == '\0') { ------------------ | Branch (148:20): [True: 1.08M, False: 6.73k] | Branch (148:41): [True: 531k, False: 549k] ------------------ 149| | 150| | /* ------------------------------------ */ 151| | /* They are exactly the same */ 152| 531k| if (VECTOR(t->values)[i] != -1) { ------------------ | | 65| 531k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (152:17): [True: 530k, False: 483] ------------------ 153| 530k| *id = VECTOR(t->values)[i]; ------------------ | | 65| 530k|#define VECTOR(v) ((v).stor_begin) ------------------ 154| 530k| return IGRAPH_SUCCESS; 155| 530k| } else { 156| 483| VECTOR(t->values)[i] = newvalue; ------------------ | | 65| 483|#define VECTOR(v) ((v).stor_begin) ------------------ 157| 483| *id = newvalue; 158| 483| return IGRAPH_SUCCESS; 159| 483| } 160| | 161| 555k| } else if (str[diff] == '\0') { ------------------ | Branch (161:20): [True: 549k, False: 6.73k] ------------------ 162| | 163| | /* ------------------------------------ */ 164| | /* str is prefix of key, follow its link if there is one */ 165| 549k| igraph_trie_node_t *node = VECTOR(t->children)[i]; ------------------ | | 65| 549k|#define VECTOR(v) ((v).stor_begin) ------------------ 166| 549k| if (node != NULL) { ------------------ | Branch (166:17): [True: 547k, False: 1.28k] ------------------ 167| 547k| return igraph_i_trie_get_node(node, key + diff, newvalue, id); 168| 547k| } else if (add) { ------------------ | Branch (168:24): [True: 1.28k, False: 0] ------------------ 169| 1.28k| igraph_trie_node_t *new_node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 38| 1.28k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 2.56k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [Folded - Ignored] | | | | | Branch (36:24): [Folded - Ignored] | | | | | Branch (36:66): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 170| 1.28k| IGRAPH_CHECK_OOM(new_node, "Cannot add to trie."); ------------------ | | 701| 1.28k| do { \ | | 702| 1.28k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 1.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.28k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 1.28k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 171| 1.28k| IGRAPH_FINALLY(igraph_free, new_node); ------------------ | | 591| 1.28k| do { \ | | 592| 1.28k| /* the following branch makes the compiler check the compatibility of \ | | 593| 1.28k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 1.28k| * incorrect destructor function with the pointer */ \ | | 595| 1.28k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 1.28k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 1.28k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 172| | 173| 1.28k| IGRAPH_STRVECTOR_INIT_FINALLY(&new_node->strs, 1); ------------------ | | 67| 1.28k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 648| 1.28k| do { \ | | | | 649| 1.28k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 1.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 1.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 1.28k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 1.28k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 1.28k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 591| 1.28k| do { \ | | | | 592| 1.28k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 1.28k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 1.28k| * incorrect destructor function with the pointer */ \ | | | | 595| 1.28k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 1.28k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 1.28k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (68:65): [Folded - Ignored] | | ------------------ ------------------ 174| 1.28k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&new_node->children, 1); ------------------ | | 51| 1.28k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 648| 1.28k| do { \ | | | | 649| 1.28k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 1.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 1.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 1.28k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 1.28k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 1.28k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 591| 1.28k| do { \ | | | | 592| 1.28k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 1.28k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 1.28k| * incorrect destructor function with the pointer */ \ | | | | 595| 1.28k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 1.28k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 1.28k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (52:65): [Folded - Ignored] | | ------------------ ------------------ 175| 1.28k| IGRAPH_VECTOR_INT_INIT_FINALLY(&new_node->values, 1); ------------------ | | 124| 1.28k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 1.28k| do { \ | | | | 649| 1.28k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 1.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 1.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 1.28k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 1.28k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 1.28k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 1.28k| do { \ | | | | 592| 1.28k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 1.28k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 1.28k| * incorrect destructor function with the pointer */ \ | | | | 595| 1.28k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 1.28k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 1.28k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 176| 1.28k| IGRAPH_CHECK(igraph_strvector_set(&new_node->strs, 0, key + diff)); ------------------ | | 648| 1.28k| do { \ | | 649| 1.28k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 1.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 1.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.28k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 1.28k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 177| 1.28k| IGRAPH_FINALLY_CLEAN(4); 178| | 179| 1.28k| VECTOR(new_node->children)[0] = 0; ------------------ | | 65| 1.28k|#define VECTOR(v) ((v).stor_begin) ------------------ 180| 1.28k| VECTOR(new_node->values)[0] = newvalue; ------------------ | | 65| 1.28k|#define VECTOR(v) ((v).stor_begin) ------------------ 181| | 182| 1.28k| VECTOR(t->children)[i] = new_node; ------------------ | | 65| 1.28k|#define VECTOR(v) ((v).stor_begin) ------------------ 183| | 184| 1.28k| *id = newvalue; 185| 1.28k| return IGRAPH_SUCCESS; 186| 1.28k| } else { 187| 0| *id = -1; 188| 0| return IGRAPH_SUCCESS; 189| 0| } 190| | 191| 549k| } else if (key[diff] == '\0' && add) { ------------------ | Branch (191:20): [True: 3.10k, False: 3.62k] | Branch (191:41): [True: 3.10k, False: 0] ------------------ 192| | 193| | /* ------------------------------------ */ 194| | /* key is prefix of str, the node has to be cut */ 195| 3.10k| char *str2; 196| | 197| 3.10k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 38| 3.10k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 6.21k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [Folded - Ignored] | | | | | Branch (36:24): [Folded - Ignored] | | | | | Branch (36:66): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 198| 3.10k| IGRAPH_CHECK_OOM(node, "Cannot add to trie."); ------------------ | | 701| 3.10k| do { \ | | 702| 3.10k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 3.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.10k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 3.10k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 199| 3.10k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 591| 3.10k| do { \ | | 592| 3.10k| /* the following branch makes the compiler check the compatibility of \ | | 593| 3.10k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 3.10k| * incorrect destructor function with the pointer */ \ | | 595| 3.10k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 3.10k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 3.10k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 200| | 201| 3.10k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1); ------------------ | | 67| 3.10k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 648| 3.10k| do { \ | | | | 649| 3.10k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 3.10k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 3.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 3.10k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 3.10k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 3.10k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 591| 3.10k| do { \ | | | | 592| 3.10k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 3.10k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 3.10k| * incorrect destructor function with the pointer */ \ | | | | 595| 3.10k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 3.10k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 3.10k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (68:65): [Folded - Ignored] | | ------------------ ------------------ 202| 3.10k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1); ------------------ | | 51| 3.10k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 648| 3.10k| do { \ | | | | 649| 3.10k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 3.10k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 3.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 3.10k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 3.10k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 3.10k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 591| 3.10k| do { \ | | | | 592| 3.10k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 3.10k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 3.10k| * incorrect destructor function with the pointer */ \ | | | | 595| 3.10k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 3.10k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 3.10k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (52:65): [Folded - Ignored] | | ------------------ ------------------ 203| 3.10k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1); ------------------ | | 124| 3.10k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 3.10k| do { \ | | | | 649| 3.10k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 3.10k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 3.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 3.10k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 3.10k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 3.10k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 3.10k| do { \ | | | | 592| 3.10k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 3.10k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 3.10k| * incorrect destructor function with the pointer */ \ | | | | 595| 3.10k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 3.10k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 3.10k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 204| 3.10k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 648| 3.10k| do { \ | | 649| 3.10k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 3.10k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 3.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.10k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 3.10k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 205| | 206| 3.10k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 65| 3.10k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 65| 3.10k|#define VECTOR(v) ((v).stor_begin) ------------------ 207| 3.10k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 65| 3.10k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 65| 3.10k|#define VECTOR(v) ((v).stor_begin) ------------------ 208| | 209| 3.10k| str2 = strdup(str); 210| 3.10k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 701| 3.10k| do { \ | | 702| 3.10k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 3.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.10k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 3.10k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 211| 3.10k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 591| 3.10k| do { \ | | 592| 3.10k| /* the following branch makes the compiler check the compatibility of \ | | 593| 3.10k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 3.10k| * incorrect destructor function with the pointer */ \ | | 595| 3.10k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 3.10k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 3.10k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 212| 3.10k| str2[diff] = '\0'; 213| | 214| 3.10k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 648| 3.10k| do { \ | | 649| 3.10k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 3.10k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 3.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.10k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 3.10k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 215| | 216| 3.10k| IGRAPH_FREE(str2); ------------------ | | 41| 3.10k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 217| 3.10k| IGRAPH_FINALLY_CLEAN(5); 218| | 219| 3.10k| VECTOR(t->values)[i] = newvalue; ------------------ | | 65| 3.10k|#define VECTOR(v) ((v).stor_begin) ------------------ 220| 3.10k| VECTOR(t->children)[i] = node; ------------------ | | 65| 3.10k|#define VECTOR(v) ((v).stor_begin) ------------------ 221| | 222| 3.10k| *id = newvalue; 223| 3.10k| return IGRAPH_SUCCESS; 224| | 225| 3.62k| } else if (add) { ------------------ | Branch (225:20): [True: 3.62k, False: 0] ------------------ 226| | 227| | /* ------------------------------------ */ 228| | /* the first diff characters match */ 229| 3.62k| char *str2; 230| | 231| 3.62k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 38| 3.62k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 7.24k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [Folded - Ignored] | | | | | Branch (36:24): [Folded - Ignored] | | | | | Branch (36:66): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 232| 3.62k| IGRAPH_CHECK_OOM(node, "Cannot add to trie."); ------------------ | | 701| 3.62k| do { \ | | 702| 3.62k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 3.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.62k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 3.62k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 233| 3.62k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 591| 3.62k| do { \ | | 592| 3.62k| /* the following branch makes the compiler check the compatibility of \ | | 593| 3.62k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 3.62k| * incorrect destructor function with the pointer */ \ | | 595| 3.62k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 3.62k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 3.62k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 234| | 235| 3.62k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2); ------------------ | | 67| 3.62k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 648| 3.62k| do { \ | | | | 649| 3.62k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 3.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 3.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 3.62k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 3.62k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 3.62k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 591| 3.62k| do { \ | | | | 592| 3.62k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 3.62k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 3.62k| * incorrect destructor function with the pointer */ \ | | | | 595| 3.62k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 3.62k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 3.62k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (68:65): [Folded - Ignored] | | ------------------ ------------------ 236| 3.62k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2); ------------------ | | 51| 3.62k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 648| 3.62k| do { \ | | | | 649| 3.62k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 3.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 3.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 3.62k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 3.62k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 3.62k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 591| 3.62k| do { \ | | | | 592| 3.62k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 3.62k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 3.62k| * incorrect destructor function with the pointer */ \ | | | | 595| 3.62k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 3.62k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 3.62k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (52:65): [Folded - Ignored] | | ------------------ ------------------ 237| 3.62k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 2); ------------------ | | 124| 3.62k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 3.62k| do { \ | | | | 649| 3.62k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 3.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 3.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 3.62k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 3.62k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 3.62k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 3.62k| do { \ | | | | 592| 3.62k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 3.62k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 3.62k| * incorrect destructor function with the pointer */ \ | | | | 595| 3.62k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 3.62k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 3.62k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 238| 3.62k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 648| 3.62k| do { \ | | 649| 3.62k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 3.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 3.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.62k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 3.62k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 239| 3.62k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff)); ------------------ | | 648| 3.62k| do { \ | | 649| 3.62k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 3.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 3.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.62k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 3.62k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 240| 3.62k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 65| 3.62k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 65| 3.62k|#define VECTOR(v) ((v).stor_begin) ------------------ 241| 3.62k| VECTOR(node->children)[1] = 0; ------------------ | | 65| 3.62k|#define VECTOR(v) ((v).stor_begin) ------------------ 242| 3.62k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 65| 3.62k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 65| 3.62k|#define VECTOR(v) ((v).stor_begin) ------------------ 243| 3.62k| VECTOR(node->values)[1] = newvalue; ------------------ | | 65| 3.62k|#define VECTOR(v) ((v).stor_begin) ------------------ 244| | 245| 3.62k| str2 = strdup(str); 246| 3.62k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 701| 3.62k| do { \ | | 702| 3.62k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 3.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.62k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 3.62k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 247| | 248| 3.62k| str2[diff] = '\0'; 249| 3.62k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 591| 3.62k| do { \ | | 592| 3.62k| /* the following branch makes the compiler check the compatibility of \ | | 593| 3.62k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 3.62k| * incorrect destructor function with the pointer */ \ | | 595| 3.62k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 3.62k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 3.62k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 250| | 251| 3.62k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 648| 3.62k| do { \ | | 649| 3.62k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 3.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 3.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.62k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 3.62k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 252| | 253| 3.62k| IGRAPH_FREE(str2); ------------------ | | 41| 3.62k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 254| 3.62k| IGRAPH_FINALLY_CLEAN(5); 255| | 256| 3.62k| VECTOR(t->values)[i] = -1; ------------------ | | 65| 3.62k|#define VECTOR(v) ((v).stor_begin) ------------------ 257| 3.62k| VECTOR(t->children)[i] = node; ------------------ | | 65| 3.62k|#define VECTOR(v) ((v).stor_begin) ------------------ 258| | 259| 3.62k| *id = newvalue; 260| 3.62k| return IGRAPH_SUCCESS; 261| 3.62k| } else { 262| | 263| | /* ------------------------------------------------- */ 264| | /* No match, but we requested not to add the new key */ 265| 0| *id = -1; 266| 0| return IGRAPH_SUCCESS; 267| 0| } 268| 6.52M| } 269| | 270| | /* ------------------------------------ */ 271| | /* Nothing matches */ 272| | 273| 11.6k| if (add) { ------------------ | Branch (273:9): [True: 11.6k, False: 0] ------------------ 274| | /* Memory saving at the cost of performance may be possible by using the pattern 275| | * CHECK(reserve(vec, size(vec) + 1)); 276| | * push_back(vec, value); 277| | * This was the original pattern used before igraph 0.10. */ 278| 11.6k| IGRAPH_CHECK(igraph_strvector_push_back(&t->strs, key)); ------------------ | | 648| 11.6k| do { \ | | 649| 11.6k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 11.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 11.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 11.6k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 11.6k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 279| 11.6k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t->children, NULL)); ------------------ | | 648| 11.6k| do { \ | | 649| 11.6k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 11.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 11.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 11.6k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 11.6k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 280| 11.6k| IGRAPH_CHECK(igraph_vector_int_push_back(&t->values, newvalue)); ------------------ | | 648| 11.6k| do { \ | | 649| 11.6k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 11.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 11.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 11.6k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 11.6k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 281| 11.6k| *id = newvalue; 282| 11.6k| } else { 283| 0| *id = -1; 284| 0| } 285| | 286| 11.6k| return IGRAPH_SUCCESS; 287| 11.6k|} trie.c:igraph_i_strdiff: 112| 6.52M|static size_t igraph_i_strdiff(const char *str, const char *key) { 113| 6.52M| size_t diff = 0; 114| 8.15M| while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) { ------------------ | Branch (114:12): [True: 7.62M, False: 534k] | Branch (114:33): [True: 7.07M, False: 549k] | Branch (114:54): [True: 1.63M, False: 5.43M] ------------------ 115| 1.63M| diff++; 116| 1.63M| } 117| 6.52M| return diff; 118| 6.52M|} igraph_attribute_record_list_init: 110| 2.82k|igraph_error_t FUNCTION(init)(TYPE *v, igraph_integer_t size) { 111| 2.82k| igraph_integer_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (111:35): [True: 394, False: 2.43k] ------------------ 112| 2.82k| IGRAPH_ASSERT(size >= 0); ------------------ | | 916| 2.82k| do { \ | | 917| 2.82k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.82k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.82k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.82k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 113| 2.82k| v->stor_begin = IGRAPH_CALLOC(alloc_size, ITEM_TYPE); ------------------ | | 38| 2.82k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 5.65k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 2.82k, False: 0] | | | | | Branch (36:24): [True: 2.82k, False: 0] | | | | | Branch (36:66): [True: 2.82k, False: 0] | | | | ------------------ | | ------------------ ------------------ 114| 2.82k| if (v->stor_begin == 0) { ------------------ | Branch (114:9): [True: 0, False: 2.82k] ------------------ 115| 0| IGRAPH_ERROR("Cannot initialize list.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 116| 0| } 117| 2.82k| v->stor_end = v->stor_begin + alloc_size; 118| 2.82k| v->end = v->stor_begin + size; 119| | 120| 2.82k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin, v->end)); ------------------ | | 648| 2.82k| do { \ | | 649| 2.82k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 2.82k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 2.82k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.82k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 2.82k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 121| | 122| 2.82k| return IGRAPH_SUCCESS; 123| 2.82k|} igraph_attribute_record_list_destroy: 177| 2.82k|void FUNCTION(destroy)(TYPE *v) { 178| 2.82k| IGRAPH_ASSERT(v != 0); ------------------ | | 916| 2.82k| do { \ | | 917| 2.82k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.82k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.82k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.82k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 179| | 180| 2.82k| if (v->stor_begin != 0) { ------------------ | Branch (180:9): [True: 2.82k, False: 0] ------------------ 181| 2.82k| FUNCTION(clear)(v); ------------------ | | 166| 2.82k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c) | | ------------------ | | | | 24| 2.82k|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 182| 2.82k| IGRAPH_FREE(v->stor_begin); ------------------ | | 41| 2.82k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 183| 2.82k| v->stor_begin = NULL; 184| 2.82k| } 185| 2.82k|} igraph_attribute_record_list_size: 288| 3.06k|igraph_integer_t FUNCTION(size)(const TYPE *v) { 289| 3.06k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 3.06k| do { \ | | 917| 3.06k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 3.06k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.06k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 3.06k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 290| 3.06k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 3.06k| do { \ | | 917| 3.06k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 3.06k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.06k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 3.06k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 291| 3.06k| return v->end - v->stor_begin; 292| 3.06k|} igraph_attribute_record_list_clear: 358| 2.82k|void FUNCTION(clear)(TYPE *v) { 359| 2.82k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 2.82k| do { \ | | 917| 2.82k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.82k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.82k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.82k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 360| 2.82k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 2.82k| do { \ | | 917| 2.82k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.82k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.82k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.82k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 361| 2.82k| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin, v->end); ------------------ | | 167| 2.82k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 24| 2.82k|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 362| 2.82k| v->end = v->stor_begin; 363| 2.82k|} igraph_attribute_record_list_get_ptr: 378| 1.68k|ITEM_TYPE *FUNCTION(get_ptr)(const TYPE *v, igraph_integer_t pos) { 379| 1.68k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 1.68k| do { \ | | 917| 1.68k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 1.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.68k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 1.68k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 380| 1.68k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 1.68k| do { \ | | 917| 1.68k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 1.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.68k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 1.68k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 381| 1.68k| return v->stor_begin + pos; 382| 1.68k|} igraph_attribute_record_list_push_back_new: 641| 288|igraph_error_t FUNCTION(push_back_new)(TYPE *v, ITEM_TYPE** e) { 642| 288| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v)); ------------------ | | 648| 288| do { \ | | 649| 288| igraph_error_t igraph_i_ret = (expr); \ | | 650| 288| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 288| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 643| 288| IGRAPH_CHECK(INTERNAL_FUNCTION(init_item)(v, v->end)); ------------------ | | 648| 288| do { \ | | 649| 288| igraph_error_t igraph_i_ret = (expr); \ | | 650| 288| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 288| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 644| 288| if (e) { ------------------ | Branch (644:9): [True: 288, False: 0] ------------------ 645| 288| *e = v->end; 646| 288| } 647| 288| v->end += 1; 648| 288| return IGRAPH_SUCCESS; 649| 288|} attributes.c:igraph_i_attribute_record_list_init_slice: 1069| 2.82k|static igraph_error_t INTERNAL_FUNCTION(init_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) { 1070| 2.82k| ITEM_TYPE *current; ------------------ | | 62| 2.82k| #define ITEM_TYPE BASE | | ------------------ | | | | 120| 2.82k| #define BASE igraph_attribute_record_t | | ------------------ ------------------ 1071| 2.82k| igraph_error_t retval; 1072| | 1073| 3.22k| for (current = start; current < end; current++) { ------------------ | Branch (1073:27): [True: 394, False: 2.82k] ------------------ 1074| 394| retval = INTERNAL_FUNCTION(init_item)(list, current); ------------------ | | 167| 394| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 24| 394|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1075| 394| if (retval) { ------------------ | Branch (1075:13): [True: 0, False: 394] ------------------ 1076| 0| INTERNAL_FUNCTION(destroy_slice)(list, start, current); ------------------ | | 167| 0| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 24| 0|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1077| 0| IGRAPH_CHECK(retval); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 1078| 0| } 1079| 394| } 1080| | 1081| 2.82k| return IGRAPH_SUCCESS; 1082| 2.82k|} attributes.c:igraph_i_attribute_record_list_destroy_slice: 1084| 2.82k|static void INTERNAL_FUNCTION(destroy_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) { 1085| 2.82k| IGRAPH_UNUSED(list); ------------------ | | 32| 2.82k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 1086| 3.50k| for (; start < end; start++) { ------------------ | Branch (1086:12): [True: 682, False: 2.82k] ------------------ 1087| 682| INTERNAL_FUNCTION(destroy_item)(start); ------------------ | | 167| 682| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 24| 682|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1088| 682| } 1089| 2.82k|} attributes.c:igraph_i_attribute_record_list_expand_if_full: 1095| 288|static igraph_error_t INTERNAL_FUNCTION(expand_if_full)(TYPE *v) { 1096| 288| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 288| do { \ | | 917| 288| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 288| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1097| 288| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 288| do { \ | | 917| 288| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 288| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1098| | 1099| 288| if (v->stor_end == v->end) { ------------------ | Branch (1099:9): [True: 0, False: 288] ------------------ 1100| 0| igraph_integer_t old_size = FUNCTION(size)(v); ------------------ | | 166| 0| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c) | | ------------------ | | | | 24| 0|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1101| 0| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 0|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 0|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (1101:37): [True: 0, False: 0] ------------------ 1102| 0| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 77| 0|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (1102:13): [True: 0, False: 0] ------------------ 1103| 0| IGRAPH_ERROR("Cannot add new item to list, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 1104| 0| } 1105| 0| if (new_size == 0) { ------------------ | Branch (1105:13): [True: 0, False: 0] ------------------ 1106| 0| new_size = 1; 1107| 0| } 1108| 0| IGRAPH_CHECK(FUNCTION(reserve)(v, new_size)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 1109| 0| } 1110| | 1111| 288| return IGRAPH_SUCCESS; 1112| 288|} igraph_vector_int_pair_order: 120| 890| igraph_vector_int_t* res, igraph_integer_t nodes) { 121| 890| igraph_integer_t edges = igraph_vector_int_size(v); 122| 890| igraph_vector_int_t ptr; 123| 890| igraph_vector_int_t rad; 124| 890| igraph_integer_t i, j; 125| | 126| 890| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 890| do { \ | | 917| 890| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 890| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 890] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 890| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 127| 890| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 890| do { \ | | 917| 890| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 890| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 890] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 890| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 128| | 129| 890| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1); ------------------ | | 124| 890| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 890| do { \ | | | | 649| 890| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 890| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 890| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 890] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 890| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 890| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 890| do { \ | | | | 592| 890| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 890| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 890| * incorrect destructor function with the pointer */ \ | | | | 595| 890| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 890| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 890| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 130| 890| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges); ------------------ | | 124| 890| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 890| do { \ | | | | 649| 890| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 890| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 890| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 890] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 890| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 890| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 890| do { \ | | | | 592| 890| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 890| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 890| * incorrect destructor function with the pointer */ \ | | | | 595| 890| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 890| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 890| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 131| 890| IGRAPH_CHECK(igraph_vector_int_resize(res, edges)); ------------------ | | 648| 890| do { \ | | 649| 890| igraph_error_t igraph_i_ret = (expr); \ | | 650| 890| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 890| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 890] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 890| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 132| | 133| 5.16M| for (i = 0; i < edges; i++) { ------------------ | Branch (133:17): [True: 5.15M, False: 890] ------------------ 134| 5.15M| igraph_integer_t radix = VECTOR(*v2)[i]; ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ 135| 5.15M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (135:13): [True: 5.13M, False: 20.4k] ------------------ 136| 5.13M| VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 65| 5.13M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 65| 5.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 137| 5.13M| } 138| 5.15M| VECTOR(ptr)[radix] = i + 1; ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ 139| 5.15M| } 140| | 141| 890| j = 0; 142| 73.3M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (142:17): [True: 73.3M, False: 890] ------------------ 143| 73.3M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 65| 73.3M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (143:13): [True: 20.4k, False: 73.2M] ------------------ 144| 20.4k| igraph_integer_t next = VECTOR(ptr)[i] - 1; ------------------ | | 65| 20.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 145| 20.4k| VECTOR(*res)[j++] = next; ------------------ | | 65| 20.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 146| 5.15M| while (VECTOR(rad)[next] != 0) { ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (146:20): [True: 5.13M, False: 20.4k] ------------------ 147| 5.13M| next = VECTOR(rad)[next] - 1; ------------------ | | 65| 5.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 148| 5.13M| VECTOR(*res)[j++] = next; ------------------ | | 65| 5.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 149| 5.13M| } 150| 20.4k| } 151| 73.3M| } 152| | 153| 890| igraph_vector_int_null(&ptr); 154| 890| igraph_vector_int_null(&rad); 155| | 156| 5.16M| for (i = 0; i < edges; i++) { ------------------ | Branch (156:17): [True: 5.15M, False: 890] ------------------ 157| 5.15M| igraph_integer_t edge = VECTOR(*res)[edges - i - 1]; ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ 158| 5.15M| igraph_integer_t radix = VECTOR(*v)[edge]; ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ 159| 5.15M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (159:13): [True: 5.13M, False: 20.4k] ------------------ 160| 5.13M| VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 65| 5.13M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 65| 5.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 161| 5.13M| } 162| 5.15M| VECTOR(ptr)[radix] = edge + 1; ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ 163| 5.15M| } 164| | 165| 890| j = 0; 166| 73.3M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (166:17): [True: 73.3M, False: 890] ------------------ 167| 73.3M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 65| 73.3M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (167:13): [True: 20.4k, False: 73.2M] ------------------ 168| 20.4k| igraph_integer_t next = VECTOR(ptr)[i] - 1; ------------------ | | 65| 20.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 169| 20.4k| VECTOR(*res)[j++] = next; ------------------ | | 65| 20.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 170| 5.15M| while (VECTOR(rad)[next] != 0) { ------------------ | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (170:20): [True: 5.13M, False: 20.4k] ------------------ 171| 5.13M| next = VECTOR(rad)[next] - 1; ------------------ | | 65| 5.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 172| 5.13M| VECTOR(*res)[j++] = next; ------------------ | | 65| 5.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 173| 5.13M| } 174| 20.4k| } 175| 73.3M| } 176| | 177| 890| igraph_vector_int_destroy(&ptr); 178| 890| igraph_vector_int_destroy(&rad); 179| 890| IGRAPH_FINALLY_CLEAN(2); 180| | 181| 890| return IGRAPH_SUCCESS; 182| 890|} igraph_vector_init: 135| 2.67k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_integer_t size) { 136| 2.67k| igraph_integer_t alloc_size; 137| 2.67k| IGRAPH_ASSERT(size >= 0); ------------------ | | 916| 2.67k| do { \ | | 917| 2.67k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.67k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.67k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.67k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 138| 2.67k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (138:18): [True: 0, False: 2.67k] ------------------ 139| | 140| | /* When this function fails, it should leave stor_begin set to NULL, 141| | * so that vector_destroy() is still safe to call on the vector. 142| | * This simplifies freeing partially initialized data structures, 143| | * such as adjacency lists, when an error occurs mid-initialization. */ 144| 2.67k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 38| 2.67k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 5.35k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 2.67k, False: 0] | | | | | Branch (36:24): [True: 2.67k, False: 0] | | | | | Branch (36:66): [True: 2.67k, False: 0] | | | | ------------------ | | ------------------ ------------------ 145| 2.67k| if (v->stor_begin == NULL) { ------------------ | Branch (145:9): [True: 0, False: 2.67k] ------------------ 146| 0| IGRAPH_ERROR("Cannot initialize vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 147| 0| } 148| 2.67k| v->stor_end = v->stor_begin + alloc_size; 149| 2.67k| v->end = v->stor_begin + size; 150| | 151| 2.67k| return IGRAPH_SUCCESS; 152| 2.67k|} igraph_vector_destroy: 400| 2.67k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) { 401| 2.67k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 2.67k| do { \ | | 917| 2.67k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.67k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.67k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.67k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 402| | /* vector_init() will leave stor_begin set to NULL when it fails. 403| | * We handle these cases gracefully. */ 404| 2.67k| if (v->stor_begin != NULL) { ------------------ | Branch (404:9): [True: 2.67k, False: 0] ------------------ 405| 2.67k| IGRAPH_FREE(v->stor_begin); ------------------ | | 41| 2.67k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 406| 2.67k| v->stor_begin = NULL; 407| 2.67k| } 408| 2.67k|} igraph_vector_capacity: 428| 227k|igraph_integer_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) { 429| 227k| return v->stor_end - v->stor_begin; 430| 227k|} igraph_vector_reserve: 460| 227k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_integer_t capacity) { 461| 227k| igraph_integer_t current_capacity; 462| 227k| BASE *tmp; ------------------ | | 34| 227k| #define BASE igraph_real_t ------------------ 463| | 464| 227k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 227k| do { \ | | 917| 227k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 227k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 227k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 227k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 465| 227k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 227k| do { \ | | 917| 227k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 227k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 227k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 227k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 466| 227k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 916| 227k| do { \ | | 917| 227k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 227k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 227k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 227k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 467| | 468| 227k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 175| 227k| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 227k|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 227k|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 469| | 470| 227k| if (capacity <= current_capacity) { ------------------ | Branch (470:9): [True: 226k, False: 1.24k] ------------------ 471| 226k| return IGRAPH_SUCCESS; 472| 226k| } 473| | 474| 1.24k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 40| 1.24k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 36| 2.48k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 1.24k, False: 0] | | | | | Branch (36:24): [True: 1.24k, False: 0] | | | | | Branch (36:66): [True: 1.24k, False: 0] | | | | ------------------ | | ------------------ ------------------ 475| 1.24k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 701| 1.24k| do { \ | | 702| 1.24k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 1.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.24k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 1.24k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 476| | 477| 1.24k| v->end = tmp + (v->end - v->stor_begin); 478| 1.24k| v->stor_begin = tmp; 479| 1.24k| v->stor_end = v->stor_begin + capacity; 480| | 481| 1.24k| return IGRAPH_SUCCESS; 482| 1.24k|} igraph_vector_size: 514| 320k|igraph_integer_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) { 515| 320k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 320k| do { \ | | 917| 320k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 320k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 320k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 320k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 516| 320k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 320k| do { \ | | 917| 320k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 320k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 320k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 320k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 517| 320k| return v->end - v->stor_begin; 518| 320k|} igraph_vector_push_back: 565| 317k|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) { 566| 317k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 317k| do { \ | | 917| 317k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 317k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 317k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 567| 317k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 317k| do { \ | | 917| 317k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 317k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 317k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 568| | 569| 317k| if (v->stor_end == v->end) { ------------------ | Branch (569:9): [True: 675, False: 316k] ------------------ 570| | /* full, allocate more storage */ 571| 675| igraph_integer_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 175| 675| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 675|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 675|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 572| 675| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 675|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 675|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (572:37): [True: 675, False: 0] ------------------ 573| 675| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 77| 675|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (573:13): [True: 0, False: 675] ------------------ 574| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 575| 0| } 576| 675| if (new_size == 0) { ------------------ | Branch (576:13): [True: 0, False: 675] ------------------ 577| 0| new_size = 1; 578| 0| } 579| 675| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 648| 675| do { \ | | 649| 675| igraph_error_t igraph_i_ret = (expr); \ | | 650| 675| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 675| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 675] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 675| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 580| 675| } 581| | 582| 317k| *(v->end) = e; 583| 317k| v->end += 1; 584| | 585| 317k| return IGRAPH_SUCCESS; 586| 317k|} igraph_vector_resize: 1241| 226k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_integer_t new_size) { 1242| 226k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 226k| do { \ | | 917| 226k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 226k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 226k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 226k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1243| 226k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 226k| do { \ | | 917| 226k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 226k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 226k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 226k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1244| 226k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 648| 226k| do { \ | | 649| 226k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 226k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 226k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 226k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 226k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 1245| 226k| v->end = v->stor_begin + new_size; 1246| 226k| return IGRAPH_SUCCESS; 1247| 226k|} igraph_vector_append: 2384| 117| const TYPE(igraph_vector) *from) { 2385| 117| IGRAPH_ASSERT(to != NULL); ------------------ | | 916| 117| do { \ | | 917| 117| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 117| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 117] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 117| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 2386| 117| IGRAPH_ASSERT(to->stor_begin != NULL); ------------------ | | 916| 117| do { \ | | 917| 117| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 117| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 117] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 117| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 2387| | 2388| 117| const igraph_integer_t to_size = FUNCTION(igraph_vector, size)(to); ------------------ | | 175| 117| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 117|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 117|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2389| 117| const igraph_integer_t from_size = FUNCTION(igraph_vector, size)(from); ------------------ | | 175| 117| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 117|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 117|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2390| 117| const igraph_integer_t to_capacity = FUNCTION(igraph_vector, capacity)(to); ------------------ | | 175| 117| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 117|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 117|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2391| 117| igraph_integer_t new_to_size; 2392| | 2393| 117| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size); ------------------ | | 47| 117| do { \ | | 48| 117| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 117| igraph_integer_t _safe_sum; \ | | 50| 117| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 117] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 469| 0| do { \ | | | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 472| 0| return igraph_errno; \ | | | | 473| 0| } while (0) | | | | ------------------ | | | | | Branch (473:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 117| *(res) = _safe_sum; \ | | 54| 117| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 2394| | 2395| 117| if (to_capacity < new_to_size) { ------------------ | Branch (2395:9): [True: 112, False: 5] ------------------ 2396| 112| igraph_integer_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 112|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 112|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (2396:44): [True: 112, False: 0] ------------------ 2397| 112| if (new_to_capacity < new_to_size) { ------------------ | Branch (2397:13): [True: 109, False: 3] ------------------ 2398| 109| new_to_capacity = new_to_size; 2399| 109| } 2400| 112| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity)); ------------------ | | 648| 112| do { \ | | 649| 112| igraph_error_t igraph_i_ret = (expr); \ | | 650| 112| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 112| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 112] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 112| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 2401| 112| } 2402| | 2403| 117| memcpy(to->stor_begin + to_size, from->stor_begin, 2404| 117| sizeof(BASE) * from_size); 2405| 117| to->end = to->stor_begin + new_to_size; 2406| | 2407| 117| return IGRAPH_SUCCESS; 2408| 117|} igraph_vector_swap: 2498| 223|void FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) { 2499| | 2500| 223| TYPE(igraph_vector) tmp; ------------------ | | 176| 223| #define TYPE(a) CONCAT2(a,t) | | ------------------ | | | | 25| 223|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 223|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2501| | 2502| 223| tmp = *v1; 2503| 223| *v1 = *v2; 2504| 223| *v2 = tmp; 2505| 223|} igraph_vector_int_init: 135| 20.2k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_integer_t size) { 136| 20.2k| igraph_integer_t alloc_size; 137| 20.2k| IGRAPH_ASSERT(size >= 0); ------------------ | | 916| 20.2k| do { \ | | 917| 20.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 20.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 20.2k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 20.2k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 138| 20.2k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (138:18): [True: 11.1k, False: 9.08k] ------------------ 139| | 140| | /* When this function fails, it should leave stor_begin set to NULL, 141| | * so that vector_destroy() is still safe to call on the vector. 142| | * This simplifies freeing partially initialized data structures, 143| | * such as adjacency lists, when an error occurs mid-initialization. */ 144| 20.2k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 38| 20.2k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 40.4k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 20.2k, False: 0] | | | | | Branch (36:24): [True: 20.2k, False: 0] | | | | | Branch (36:66): [True: 20.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ 145| 20.2k| if (v->stor_begin == NULL) { ------------------ | Branch (145:9): [True: 0, False: 20.2k] ------------------ 146| 0| IGRAPH_ERROR("Cannot initialize vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 147| 0| } 148| 20.2k| v->stor_end = v->stor_begin + alloc_size; 149| 20.2k| v->end = v->stor_begin + size; 150| | 151| 20.2k| return IGRAPH_SUCCESS; 152| 20.2k|} igraph_vector_int_destroy: 400| 20.2k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) { 401| 20.2k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 20.2k| do { \ | | 917| 20.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 20.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 20.2k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 20.2k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 402| | /* vector_init() will leave stor_begin set to NULL when it fails. 403| | * We handle these cases gracefully. */ 404| 20.2k| if (v->stor_begin != NULL) { ------------------ | Branch (404:9): [True: 20.2k, False: 0] ------------------ 405| 20.2k| IGRAPH_FREE(v->stor_begin); ------------------ | | 41| 20.2k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 406| 20.2k| v->stor_begin = NULL; 407| 20.2k| } 408| 20.2k|} igraph_vector_int_capacity: 428| 17.0k|igraph_integer_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) { 429| 17.0k| return v->stor_end - v->stor_begin; 430| 17.0k|} igraph_vector_int_reserve: 460| 17.0k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_integer_t capacity) { 461| 17.0k| igraph_integer_t current_capacity; 462| 17.0k| BASE *tmp; ------------------ | | 71| 17.0k| #define BASE igraph_integer_t ------------------ 463| | 464| 17.0k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 17.0k| do { \ | | 917| 17.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 17.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 17.0k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 17.0k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 465| 17.0k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 17.0k| do { \ | | 917| 17.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 17.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 17.0k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 17.0k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 466| 17.0k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 916| 17.0k| do { \ | | 917| 17.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 17.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 17.0k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 17.0k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 467| | 468| 17.0k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 183| 17.0k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 17.0k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 17.0k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 469| | 470| 17.0k| if (capacity <= current_capacity) { ------------------ | Branch (470:9): [True: 6.97k, False: 10.0k] ------------------ 471| 6.97k| return IGRAPH_SUCCESS; 472| 6.97k| } 473| | 474| 10.0k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 40| 10.0k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 36| 20.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 10.0k, False: 0] | | | | | Branch (36:24): [True: 10.0k, False: 0] | | | | | Branch (36:66): [True: 10.0k, False: 0] | | | | ------------------ | | ------------------ ------------------ 475| 10.0k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 701| 10.0k| do { \ | | 702| 10.0k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 10.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 10.0k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 10.0k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 476| | 477| 10.0k| v->end = tmp + (v->end - v->stor_begin); 478| 10.0k| v->stor_begin = tmp; 479| 10.0k| v->stor_end = v->stor_begin + capacity; 480| | 481| 10.0k| return IGRAPH_SUCCESS; 482| 10.0k|} igraph_vector_int_empty: 495| 600|igraph_bool_t FUNCTION(igraph_vector, empty)(const TYPE(igraph_vector) *v) { 496| 600| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 600| do { \ | | 917| 600| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 600| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 600] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 600| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 497| 600| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 600| do { \ | | 917| 600| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 600| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 600] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 600| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 498| 600| return v->stor_begin == v->end; 499| 600|} igraph_vector_int_size: 514| 335k|igraph_integer_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) { 515| 335k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 335k| do { \ | | 917| 335k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 335k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 335k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 335k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 516| 335k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 335k| do { \ | | 917| 335k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 335k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 335k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 335k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 517| 335k| return v->end - v->stor_begin; 518| 335k|} igraph_vector_int_push_back: 565| 12.7M|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) { 566| 12.7M| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 12.7M| do { \ | | 917| 12.7M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 12.7M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 12.7M] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 12.7M| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 567| 12.7M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 12.7M| do { \ | | 917| 12.7M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 12.7M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 12.7M] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 12.7M| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 568| | 569| 12.7M| if (v->stor_end == v->end) { ------------------ | Branch (569:9): [True: 7.61k, False: 12.6M] ------------------ 570| | /* full, allocate more storage */ 571| 7.61k| igraph_integer_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 183| 7.61k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 7.61k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 7.61k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 572| 7.61k| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 7.61k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 77| 7.61k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (572:37): [True: 7.61k, False: 0] ------------------ 573| 7.61k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 77| 7.61k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (573:13): [True: 0, False: 7.61k] ------------------ 574| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 575| 0| } 576| 7.61k| if (new_size == 0) { ------------------ | Branch (576:13): [True: 0, False: 7.61k] ------------------ 577| 0| new_size = 1; 578| 0| } 579| 7.61k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 648| 7.61k| do { \ | | 649| 7.61k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 7.61k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 7.61k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 7.61k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 7.61k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 580| 7.61k| } 581| | 582| 12.7M| *(v->end) = e; 583| 12.7M| v->end += 1; 584| | 585| 12.7M| return IGRAPH_SUCCESS; 586| 12.7M|} igraph_vector_int_null: 717| 2.05k|void FUNCTION(igraph_vector, null)(TYPE(igraph_vector) *v) { 718| 2.05k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 2.05k| do { \ | | 917| 2.05k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.05k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.05k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.05k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 719| 2.05k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 2.05k| do { \ | | 917| 2.05k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.05k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.05k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.05k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 720| 2.05k| if (FUNCTION(igraph_vector, size)(v) > 0) { ------------------ | | 183| 2.05k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 2.05k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 2.05k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ | Branch (720:9): [True: 1.78k, False: 276] ------------------ 721| 1.78k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v)); ------------------ | | 183| 1.78k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 1.78k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 1.78k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 722| 1.78k| } 723| 2.05k|} igraph_vector_int_resize: 1241| 5.30k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_integer_t new_size) { 1242| 5.30k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 5.30k| do { \ | | 917| 5.30k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 5.30k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 5.30k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 5.30k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1243| 5.30k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 5.30k| do { \ | | 917| 5.30k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 5.30k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 5.30k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 5.30k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1244| 5.30k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 648| 5.30k| do { \ | | 649| 5.30k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 5.30k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 5.30k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 5.30k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 5.30k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 1245| 5.30k| v->end = v->stor_begin + new_size; 1246| 5.30k| return IGRAPH_SUCCESS; 1247| 5.30k|} igraph_vector_int_max: 1304| 600|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector) *v) { 1305| 600| BASE max; ------------------ | | 71| 600| #define BASE igraph_integer_t ------------------ 1306| 600| BASE *ptr; ------------------ | | 71| 600| #define BASE igraph_integer_t ------------------ 1307| 600| IGRAPH_ASSERT(!FUNCTION(igraph_vector, empty)(v)); ------------------ | | 916| 600| do { \ | | 917| 600| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 600| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 600] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 600| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1308| 600| max = *(v->stor_begin); 1309| |#if defined(BASE_IGRAPH_REAL) 1310| | if (isnan(max)) { return max; }; /* Result is NaN */ 1311| |#endif 1312| 600| ptr = v->stor_begin + 1; 1313| 5.32M| while (ptr < v->end) { ------------------ | Branch (1313:12): [True: 5.32M, False: 600] ------------------ 1314| 5.32M| if ((*ptr) > max) { ------------------ | Branch (1314:13): [True: 22.8k, False: 5.30M] ------------------ 1315| 22.8k| max = *ptr; 1316| 22.8k| } 1317| |#if defined(BASE_IGRAPH_REAL) 1318| | else if (isnan(*ptr)) 1319| | return *ptr; /* Result is NaN */ 1320| |#endif 1321| 5.32M| ptr++; 1322| 5.32M| } 1323| 600| return max; 1324| 600|} igraph_vector_int_isininterval: 1809| 673| BASE high) { 1810| 673| BASE *ptr; ------------------ | | 71| 673| #define BASE igraph_integer_t ------------------ 1811| 673| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 673| do { \ | | 917| 673| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 673| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 673] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 673| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1812| 673| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 673| do { \ | | 917| 673| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 673| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 673] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 673| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 1813| 5.24M| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (1813:31): [True: 5.24M, False: 445] ------------------ 1814| | /* Note that the following is not equivalent to *ptr < low || *ptr > high 1815| | * when *ptr is NaN! */ 1816| 5.24M| if (!(*ptr >= low && *ptr <= high)) { ------------------ | Branch (1816:15): [True: 5.24M, False: 0] | Branch (1816:30): [True: 5.24M, False: 228] ------------------ 1817| 228| return 0; 1818| 228| } 1819| 5.24M| } 1820| 445| return 1; 1821| 673|} igraph_vector_ptr_init: 87| 10.3k|igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_integer_t size) { 88| 10.3k| igraph_integer_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (88:35): [True: 8.01k, False: 2.33k] ------------------ 89| 10.3k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 10.3k| do { \ | | 917| 10.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 10.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 10.3k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 10.3k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 90| 10.3k| if (size < 0) { ------------------ | Branch (90:9): [True: 0, False: 10.3k] ------------------ 91| 0| size = 0; 92| 0| } 93| 10.3k| v->stor_begin = IGRAPH_CALLOC(alloc_size, void*); ------------------ | | 38| 10.3k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 20.7k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 10.3k, False: 0] | | | | | Branch (36:24): [True: 10.3k, False: 0] | | | | | Branch (36:66): [True: 10.3k, False: 0] | | | | ------------------ | | ------------------ ------------------ 94| 10.3k| if (v->stor_begin == 0) { ------------------ | Branch (94:9): [True: 0, False: 10.3k] ------------------ 95| 0| IGRAPH_ERROR("vector ptr init failed", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 96| 0| } 97| 10.3k| v->stor_end = v->stor_begin + alloc_size; 98| 10.3k| v->end = v->stor_begin + size; 99| 10.3k| v->item_destructor = 0; 100| | 101| 10.3k| return IGRAPH_SUCCESS; 102| 10.3k|} igraph_vector_ptr_destroy: 133| 10.3k|void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) { 134| 10.3k| IGRAPH_ASSERT(v != 0); ------------------ | | 916| 10.3k| do { \ | | 917| 10.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 10.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 10.3k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 10.3k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 135| 10.3k| if (v->stor_begin != 0) { ------------------ | Branch (135:9): [True: 10.3k, False: 0] ------------------ 136| 10.3k| IGRAPH_FREE(v->stor_begin); ------------------ | | 41| 10.3k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 137| 10.3k| v->stor_begin = NULL; 138| 10.3k| } 139| 10.3k|} igraph_vector_ptr_reserve: 216| 3.70k|igraph_error_t igraph_vector_ptr_reserve(igraph_vector_ptr_t* v, igraph_integer_t capacity) { 217| 3.70k| igraph_integer_t actual_size = igraph_vector_ptr_size(v); 218| 3.70k| void **tmp; 219| 3.70k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 3.70k| do { \ | | 917| 3.70k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 3.70k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.70k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 3.70k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 220| 3.70k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 3.70k| do { \ | | 917| 3.70k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 3.70k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.70k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 3.70k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 221| 3.70k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 916| 3.70k| do { \ | | 917| 3.70k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 3.70k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.70k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 3.70k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 222| | 223| 3.70k| if (capacity <= igraph_vector_ptr_size(v)) { ------------------ | Branch (223:9): [True: 0, False: 3.70k] ------------------ 224| 0| return IGRAPH_SUCCESS; 225| 0| } 226| | 227| 3.70k| tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) capacity, void*); ------------------ | | 40| 3.70k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 36| 7.40k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 3.70k, False: 0] | | | | | Branch (36:24): [True: 3.70k, False: 0] | | | | | Branch (36:66): [True: 3.70k, False: 0] | | | | ------------------ | | ------------------ ------------------ 228| 3.70k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for pointer vector."); ------------------ | | 701| 3.70k| do { \ | | 702| 3.70k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 3.70k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.70k] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 3.70k| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 229| | 230| 3.70k| v->stor_begin = tmp; 231| 3.70k| v->stor_end = v->stor_begin + capacity; 232| 3.70k| v->end = v->stor_begin + actual_size; 233| | 234| 3.70k| return IGRAPH_SUCCESS; 235| 3.70k|} igraph_vector_ptr_size: 292| 17.7k|igraph_integer_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v) { 293| 17.7k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 17.7k| do { \ | | 917| 17.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 17.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 17.7k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 17.7k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 294| 17.7k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 17.7k| do { \ | | 917| 17.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 17.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 17.7k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 17.7k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 295| 17.7k| return v->end - v->stor_begin; 296| 17.7k|} igraph_vector_ptr_push_back: 361| 11.6k|igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) { 362| 11.6k| IGRAPH_ASSERT(v != NULL); ------------------ | | 916| 11.6k| do { \ | | 917| 11.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 11.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 11.6k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 11.6k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 363| 11.6k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 916| 11.6k| do { \ | | 917| 11.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 11.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 11.6k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 11.6k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 364| | 365| | /* full, allocate more storage */ 366| 11.6k| if (v->stor_end == v->end) { ------------------ | Branch (366:9): [True: 3.70k, False: 7.98k] ------------------ 367| 3.70k| igraph_integer_t new_size = igraph_vector_ptr_size(v) * 2; 368| 3.70k| if (new_size == 0) { ------------------ | Branch (368:13): [True: 0, False: 3.70k] ------------------ 369| 0| new_size = 1; 370| 0| } 371| 3.70k| IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size)); ------------------ | | 648| 3.70k| do { \ | | 649| 3.70k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 3.70k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 3.70k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 3.70k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 3.70k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 372| 3.70k| } 373| | 374| 11.6k| *(v->end) = e; 375| 11.6k| v->end += 1; 376| | 377| 11.6k| return IGRAPH_SUCCESS; 378| 11.6k|} igraph_attribute_record_init: 127| 682|) { 128| 682| attr->name = NULL; 129| 682| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED; 130| 682| attr->value.as_raw = NULL; 131| 682| attr->default_value.string = NULL; 132| | 133| 682| IGRAPH_CHECK(igraph_attribute_record_set_name(attr, name)); ------------------ | | 648| 682| do { \ | | 649| 682| igraph_error_t igraph_i_ret = (expr); \ | | 650| 682| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 682| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 682] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 682| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 134| 682| IGRAPH_CHECK(igraph_attribute_record_set_type(attr, type)); ------------------ | | 648| 682| do { \ | | 649| 682| igraph_error_t igraph_i_ret = (expr); \ | | 650| 682| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 682| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 682] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 682| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 135| | 136| 682| return IGRAPH_SUCCESS; 137| 682|} igraph_attribute_record_destroy: 240| 682|void igraph_attribute_record_destroy(igraph_attribute_record_t *attr) { 241| 682| igraph_i_attribute_record_destroy_values(attr); 242| | 243| 682| if (attr->name) { ------------------ | Branch (243:9): [True: 682, False: 0] ------------------ 244| 682| igraph_free(attr->name); 245| 682| attr->name = NULL; 246| 682| } 247| 682|} igraph_attribute_record_size: 294| 576|igraph_integer_t igraph_attribute_record_size(const igraph_attribute_record_t *attr) { 295| 576| IGRAPH_ASSERT(attr != NULL); ------------------ | | 916| 576| do { \ | | 917| 576| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 576| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 576] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 576| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 296| | 297| 576| switch (attr->type) { 298| 234| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (298:9): [True: 234, False: 342] ------------------ 299| 234| return igraph_vector_size(attr->value.as_vector); 300| | 301| 342| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (301:9): [True: 342, False: 234] ------------------ 302| 342| return igraph_strvector_size(attr->value.as_strvector); 303| | 304| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (304:9): [True: 0, False: 576] ------------------ 305| 0| return igraph_vector_bool_size(attr->value.as_vector_bool); 306| | 307| 0| case IGRAPH_ATTRIBUTE_UNSPECIFIED: ------------------ | Branch (307:9): [True: 0, False: 576] ------------------ 308| 0| return 0; 309| | 310| 0| default: ------------------ | Branch (310:9): [True: 0, False: 576] ------------------ 311| 0| IGRAPH_ERRORF("Unsupported attribute type: %d", IGRAPH_EINVAL, (int) attr->type); ------------------ | | 469| 0| do { \ | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | 472| 0| return igraph_errno; \ | | 473| 0| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 312| 576| } 313| 576|} igraph_attribute_record_resize: 331| 138|) { 332| 138| igraph_integer_t i; 333| 138| igraph_vector_t *vec; 334| 138| igraph_vector_bool_t *log; 335| 138| igraph_strvector_t *str; 336| | 337| 138| IGRAPH_ASSERT(attr != NULL); ------------------ | | 916| 138| do { \ | | 917| 138| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 138| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 138] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 138| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 338| | 339| 138| switch (attr->type) { 340| | 341| 0| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (341:9): [True: 0, False: 138] ------------------ 342| 0| vec = attr->value.as_vector; 343| 0| i = igraph_vector_size(vec); 344| 0| IGRAPH_CHECK(igraph_vector_resize(vec, new_size)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 345| 0| while (i < new_size) { ------------------ | Branch (345:20): [True: 0, False: 0] ------------------ 346| 0| VECTOR(*vec)[i++] = attr->default_value.numeric; ------------------ | | 65| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 347| 0| } 348| 0| break; 349| | 350| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (350:9): [True: 0, False: 138] ------------------ 351| 0| log = attr->value.as_vector_bool; 352| 0| i = igraph_vector_bool_size(log); 353| 0| IGRAPH_CHECK(igraph_vector_bool_resize(log, new_size)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 354| 0| while (i < new_size) { ------------------ | Branch (354:20): [True: 0, False: 0] ------------------ 355| 0| VECTOR(*log)[i++] = attr->default_value.boolean; ------------------ | | 65| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 356| 0| } 357| 0| break; 358| | 359| 138| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (359:9): [True: 138, False: 0] ------------------ 360| 138| str = attr->value.as_strvector; 361| 138| if (attr->default_value.string == 0 || (*attr->default_value.string == 0)) { ------------------ | Branch (361:17): [True: 138, False: 0] | Branch (361:52): [True: 0, False: 0] ------------------ 362| 138| IGRAPH_CHECK(igraph_strvector_resize(str, new_size)); ------------------ | | 648| 138| do { \ | | 649| 138| igraph_error_t igraph_i_ret = (expr); \ | | 650| 138| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 138| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 138] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 138| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 363| 138| } else { 364| 0| i = igraph_strvector_size(str); 365| 0| IGRAPH_CHECK(igraph_strvector_resize(str, new_size)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 366| 0| while (i < new_size) { ------------------ | Branch (366:24): [True: 0, False: 0] ------------------ 367| 0| IGRAPH_CHECK(igraph_strvector_set(str, i++, attr->default_value.string)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 368| 0| } 369| 0| } 370| 138| break; 371| | 372| 138| case IGRAPH_ATTRIBUTE_UNSPECIFIED: ------------------ | Branch (372:9): [True: 0, False: 138] ------------------ 373| 0| IGRAPH_ERROR("Attribute record has no type yet.", IGRAPH_EINVAL); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 374| 0| break; 375| | 376| 0| default: ------------------ | Branch (376:9): [True: 0, False: 138] ------------------ 377| 0| IGRAPH_ERRORF("Unsupported attribute type: %d", IGRAPH_EINVAL, (int) attr->type); ------------------ | | 469| 0| do { \ | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | 472| 0| return igraph_errno; \ | | 473| 0| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 378| 138| } 379| | 380| 138| return IGRAPH_SUCCESS; 381| 138|} igraph_attribute_record_set_default_numeric: 398| 340|) { 399| 340| if (attr->type != IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (399:9): [True: 0, False: 340] ------------------ 400| 0| return IGRAPH_EINVAL; 401| 0| } 402| | 403| 340| attr->default_value.numeric = value; 404| 340| return IGRAPH_SUCCESS; 405| 340|} igraph_attribute_record_set_name: 482| 1.36k|) { 483| 1.36k| char* new_name; 484| | 485| 1.36k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 916| 1.36k| do { \ | | 917| 1.36k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 1.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.36k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 1.36k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 486| | 487| 1.36k| if (name != NULL) { ------------------ | Branch (487:9): [True: 682, False: 682] ------------------ 488| 682| new_name = strdup(name); 489| 682| IGRAPH_CHECK_OOM(new_name, "Insufficient memory for allocating attribute name."); ------------------ | | 701| 682| do { \ | | 702| 682| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 682| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 682] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 682| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 490| 682| } else { 491| 682| new_name = NULL; 492| 682| } 493| | 494| 1.36k| if (attr->name) { ------------------ | Branch (494:9): [True: 0, False: 1.36k] ------------------ 495| 0| igraph_free(attr->name); 496| 0| } 497| | 498| 1.36k| attr->name = new_name; 499| | 500| 1.36k| return IGRAPH_SUCCESS; 501| 1.36k|} igraph_attribute_record_set_type: 538| 1.36k|) { 539| 1.36k| void* ptr; 540| | 541| 1.36k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 916| 1.36k| do { \ | | 917| 1.36k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 1.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.36k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 1.36k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 542| | 543| 1.36k| if (attr->type != type) { ------------------ | Branch (543:9): [True: 682, False: 682] ------------------ 544| 682| switch (type) { 545| 340| case IGRAPH_ATTRIBUTE_NUMERIC: { ------------------ | Branch (545:13): [True: 340, False: 342] ------------------ 546| 340| igraph_vector_t* vec = IGRAPH_CALLOC(1, igraph_vector_t); ------------------ | | 38| 340|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 680| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [Folded - Ignored] | | | | | Branch (36:24): [Folded - Ignored] | | | | | Branch (36:66): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 547| 340| IGRAPH_CHECK_OOM(vec, "Insufficient memory for attribute record."); ------------------ | | 701| 340| do { \ | | 702| 340| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 340| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 340] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 340| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 548| 340| IGRAPH_FINALLY(igraph_free, vec); ------------------ | | 591| 340| do { \ | | 592| 340| /* the following branch makes the compiler check the compatibility of \ | | 593| 340| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 340| * incorrect destructor function with the pointer */ \ | | 595| 340| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 340| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 340| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 549| 340| IGRAPH_VECTOR_INIT_FINALLY(vec, 0); ------------------ | | 109| 340| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 648| 340| do { \ | | | | 649| 340| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 340| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 340| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 340] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 340| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 340| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 591| 340| do { \ | | | | 592| 340| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 340| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 340| * incorrect destructor function with the pointer */ \ | | | | 595| 340| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 340| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 340| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 550| 340| ptr = vec; 551| 340| } 552| 0| break; 553| | 554| 342| case IGRAPH_ATTRIBUTE_STRING: { ------------------ | Branch (554:13): [True: 342, False: 340] ------------------ 555| 342| igraph_strvector_t* strvec = IGRAPH_CALLOC(1, igraph_strvector_t); ------------------ | | 38| 342|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 684| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [Folded - Ignored] | | | | | Branch (36:24): [Folded - Ignored] | | | | | Branch (36:66): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 556| 342| IGRAPH_CHECK_OOM(strvec, "Insufficient memory for attribute record."); ------------------ | | 701| 342| do { \ | | 702| 342| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 342| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 342] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 342| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 557| 342| IGRAPH_FINALLY(igraph_free, strvec); ------------------ | | 591| 342| do { \ | | 592| 342| /* the following branch makes the compiler check the compatibility of \ | | 593| 342| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 342| * incorrect destructor function with the pointer */ \ | | 595| 342| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 342| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 342| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 558| 342| IGRAPH_CHECK(igraph_strvector_init(strvec, 0)); ------------------ | | 648| 342| do { \ | | 649| 342| igraph_error_t igraph_i_ret = (expr); \ | | 650| 342| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 342| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 342] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 342| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 559| 342| IGRAPH_FINALLY(igraph_strvector_destroy, strvec); ------------------ | | 591| 342| do { \ | | 592| 342| /* the following branch makes the compiler check the compatibility of \ | | 593| 342| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 342| * incorrect destructor function with the pointer */ \ | | 595| 342| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 342| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 342| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 560| 342| ptr = strvec; 561| 342| } 562| 0| break; 563| | 564| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: { ------------------ | Branch (564:13): [True: 0, False: 682] ------------------ 565| 0| igraph_vector_bool_t* boolvec = IGRAPH_CALLOC(1, igraph_vector_bool_t); ------------------ | | 38| 0|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 0| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [Folded - Ignored] | | | | | Branch (36:24): [Folded - Ignored] | | | | | Branch (36:66): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 566| 0| IGRAPH_CHECK_OOM(boolvec, "Insufficient memory for attribute record."); ------------------ | | 701| 0| do { \ | | 702| 0| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 0| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 567| 0| IGRAPH_FINALLY(igraph_free, boolvec); ------------------ | | 591| 0| do { \ | | 592| 0| /* the following branch makes the compiler check the compatibility of \ | | 593| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 0| * incorrect destructor function with the pointer */ \ | | 595| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 0| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 568| 0| IGRAPH_VECTOR_BOOL_INIT_FINALLY(boolvec, 0); ------------------ | | 114| 0| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \ | | ------------------ | | | | 648| 0| do { \ | | | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 0| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 115| 0| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0) | | ------------------ | | | | 591| 0| do { \ | | | | 592| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 0| * incorrect destructor function with the pointer */ \ | | | | 595| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 0| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (115:65): [Folded - Ignored] | | ------------------ ------------------ 569| 0| ptr = boolvec; 570| 0| } 571| 0| break; 572| | 573| 0| default: ------------------ | Branch (573:13): [True: 0, False: 682] ------------------ 574| 0| IGRAPH_ERRORF("Unsupported attribute type: %d", IGRAPH_EINVAL, (int) type); ------------------ | | 469| 0| do { \ | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | 472| 0| return igraph_errno; \ | | 473| 0| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 575| 682| } 576| | 577| 682| igraph_i_attribute_record_set_type(attr, type, ptr); 578| 682| IGRAPH_FINALLY_CLEAN(2); 579| 682| } 580| | 581| 1.36k| return IGRAPH_SUCCESS; 582| 1.36k|} igraph_i_attribute_init: 617| 811|) { 618| 811| graph->attr = NULL; 619| 811| if (igraph_i_attribute_table) { ------------------ | Branch (619:9): [True: 811, False: 0] ------------------ 620| 811| IGRAPH_CHECK(igraph_i_attribute_table->init(graph, attr)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 621| 811| if (graph->attr == NULL) { ------------------ | Branch (621:13): [True: 0, False: 811] ------------------ 622| 0| IGRAPH_ERROR("Attribute handler did not initialize attr pointer", IGRAPH_FAILURE); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 623| 0| } 624| 811| } 625| 811| return IGRAPH_SUCCESS; 626| 811|} igraph_i_attribute_destroy: 628| 811|void igraph_i_attribute_destroy(igraph_t *graph) { 629| 811| if (graph->attr && igraph_i_attribute_table) { ------------------ | Branch (629:9): [True: 811, False: 0] | Branch (629:24): [True: 811, False: 0] ------------------ 630| 811| igraph_i_attribute_table->destroy(graph); 631| 811| } 632| 811| graph->attr = NULL; 633| 811|} 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| 445|) { 691| 445| if (igraph_i_attribute_table) { ------------------ | Branch (691:9): [True: 445, False: 0] ------------------ 692| 445| return igraph_i_attribute_table->add_edges(graph, edges, attr); 693| 445| } else { 694| 0| return IGRAPH_SUCCESS; 695| 0| } 696| 445|} igraph_set_attribute_table: 886| 2.33k|igraph_set_attribute_table(const igraph_attribute_table_t * table) { 887| 2.33k| igraph_attribute_table_t *old = igraph_i_attribute_table; 888| 2.33k| igraph_i_attribute_table = (igraph_attribute_table_t*) table; 889| 2.33k| return old; 890| 2.33k|} attributes.c:igraph_i_attribute_record_destroy_values: 184| 1.36k|static void igraph_i_attribute_record_destroy_values(igraph_attribute_record_t *attr) { 185| 1.36k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 916| 1.36k| do { \ | | 917| 1.36k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 1.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.36k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 1.36k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 186| | 187| 1.36k| if (attr->value.as_raw) { ------------------ | Branch (187:9): [True: 682, False: 682] ------------------ 188| 682| switch (attr->type) { 189| 340| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (189:13): [True: 340, False: 342] ------------------ 190| 340| igraph_vector_destroy(attr->value.as_vector); 191| 340| break; 192| | 193| 342| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (193:13): [True: 342, False: 340] ------------------ 194| 342| igraph_strvector_destroy(attr->value.as_strvector); 195| 342| break; 196| | 197| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (197:13): [True: 0, False: 682] ------------------ 198| 0| igraph_vector_bool_destroy(attr->value.as_vector_bool); 199| 0| break; 200| | 201| 0| default: ------------------ | Branch (201:13): [True: 0, False: 682] ------------------ 202| 0| break; 203| 682| } 204| | 205| 682| igraph_free(attr->value.as_raw); 206| 682| attr->value.as_raw = NULL; 207| 682| } 208| | 209| 1.36k| switch (attr->type) { 210| 340| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (210:9): [True: 340, False: 1.02k] ------------------ 211| 340| attr->default_value.numeric = 0; 212| 340| break; 213| | 214| 342| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (214:9): [True: 342, False: 1.02k] ------------------ 215| 342| if (attr->default_value.string) { ------------------ | Branch (215:17): [True: 0, False: 342] ------------------ 216| 0| igraph_free(attr->default_value.string); 217| 0| attr->default_value.string = NULL; 218| 0| } 219| 342| break; 220| | 221| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (221:9): [True: 0, False: 1.36k] ------------------ 222| 0| attr->default_value.boolean = 0; 223| 0| break; 224| | 225| 682| default: ------------------ | Branch (225:9): [True: 682, False: 682] ------------------ 226| 682| break; 227| 1.36k| } 228| | 229| 1.36k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED; 230| 1.36k|} attributes.c:igraph_i_attribute_record_set_type: 505| 682|) { 506| 682| bool type_changed = attr->type != type; 507| | 508| 682| if (type_changed || attr->value.as_raw != ptr) { ------------------ | Branch (508:9): [True: 682, False: 0] | Branch (508:25): [True: 0, False: 0] ------------------ 509| 682| igraph_i_attribute_record_destroy_values(attr); 510| 682| attr->type = type; 511| 682| attr->value.as_raw = ptr; 512| 682| } 513| | 514| 682| if (type_changed && type == IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (514:9): [True: 682, False: 0] | Branch (514:25): [True: 340, False: 342] ------------------ 515| 340| IGRAPH_ASSERT( ------------------ | | 916| 340| do { \ | | 917| 340| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 340| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 340] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 340| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 516| 340| igraph_attribute_record_set_default_numeric(attr, IGRAPH_NAN) == IGRAPH_SUCCESS 517| 340| ); 518| 340| } 519| 682|} attributes.c:igraph_i_attribute_record_list_init_item: 596| 682|) { 597| 682| IGRAPH_UNUSED(list); ------------------ | | 32| 682|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 598| 682| return igraph_attribute_record_init(item, NULL, IGRAPH_ATTRIBUTE_UNSPECIFIED); 599| 682|} attributes.c:igraph_i_attribute_record_list_destroy_item: 607| 682|static void igraph_i_attribute_record_list_destroy_item(igraph_attribute_record_t* item) { 608| 682| igraph_attribute_record_destroy(item); 609| 682|} igraph_i_property_cache_init: 30| 811|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) { 31| 811| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32); ------------------ | | 69| 811|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)])) ------------------ 32| | 33| 811| memset(cache->value, 0, sizeof(cache->value)); 34| 811| cache->known = 0; 35| 811| return IGRAPH_SUCCESS; 36| 811|} igraph_i_property_cache_destroy: 51| 811|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) { 52| 811| IGRAPH_UNUSED(cache); ------------------ | | 32| 811|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 53| | /* Nothing to do */ 54| 811|} igraph_i_property_cache_invalidate_conditionally: 180| 1.92k|) { 181| 1.92k| uint32_t invalidate = ~keep_always; 182| 1.92k| uint32_t mask; 183| 1.92k| uint32_t maybe_keep; 184| 1.92k| igraph_bool_t cached_value; 185| | 186| 1.92k| assert(graph->cache != NULL); 187| | 188| | /* The bits of maybe_keep are set to 1 for those properties that are: 189| | * 190| | * - currently cached 191| | * - should _probably_ be invalidated 192| | * - _but_ the current cached value of the property may change the decision 193| | */ 194| 1.92k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true); 195| | 196| 1.92k| if (maybe_keep) { ------------------ | Branch (196:9): [True: 0, False: 1.92k] ------------------ 197| 0| for (igraph_cached_property_t prop = (igraph_cached_property_t ) 0; prop < IGRAPH_PROP_I_SIZE; ++prop) { ------------------ | Branch (197:77): [True: 0, False: 0] ------------------ 198| 0| mask = 1 << prop; 199| 0| if (maybe_keep & mask) { ------------------ | Branch (199:17): [True: 0, False: 0] ------------------ 200| | /* if we get here, we know that the property is cached; we have 201| | * masked maybe_keep with graph->cache->known */ 202| 0| cached_value = igraph_i_property_cache_get_bool(graph, prop); 203| 0| if ( 204| 0| ((keep_when_false & mask) && !cached_value) || ------------------ | Branch (204:22): [True: 0, False: 0] | Branch (204:50): [True: 0, False: 0] ------------------ 205| 0| ((keep_when_true & mask) && cached_value) ------------------ | Branch (205:22): [True: 0, False: 0] | Branch (205:49): [True: 0, False: 0] ------------------ 206| 0| ) { 207| 0| invalidate &= ~mask; 208| 0| } 209| 0| } 210| 0| } 211| 0| } 212| | 213| 1.92k| graph->cache->known &= ~invalidate; 214| 1.92k|} cattributes.c:igraph_i_cattribute_init: 196| 811|) { 197| 811| igraph_i_cattributes_t *nattr; 198| | 199| 811| nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t); ------------------ | | 38| 811|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 1.62k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [Folded - Ignored] | | | | | Branch (36:24): [Folded - Ignored] | | | | | Branch (36:66): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 200| 811| IGRAPH_CHECK_OOM(nattr, "Insufficient memory to allocate attribute storage."); ------------------ | | 701| 811| do { \ | | 702| 811| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 811| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 201| 811| IGRAPH_FINALLY(igraph_free, nattr); ------------------ | | 591| 811| do { \ | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 811| * incorrect destructor function with the pointer */ \ | | 595| 811| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 811| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 202| | 203| 811| if (attr) { ------------------ | Branch (203:9): [True: 0, False: 811] ------------------ 204| 0| IGRAPH_CHECK(igraph_attribute_record_list_init_copy(&nattr->gal, attr)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 205| 811| } else { 206| 811| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->gal, 0)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 207| 811| } 208| 811| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->gal); ------------------ | | 591| 811| do { \ | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 811| * incorrect destructor function with the pointer */ \ | | 595| 811| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 811| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 209| | 210| 811| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->val, 0)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 211| 811| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->val); ------------------ | | 591| 811| do { \ | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 811| * incorrect destructor function with the pointer */ \ | | 595| 811| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 811| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 212| | 213| 811| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->eal, 0)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 214| 811| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->eal); ------------------ | | 591| 811| do { \ | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 811| * incorrect destructor function with the pointer */ \ | | 595| 811| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 811| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 215| | 216| 811| graph->attr = nattr; 217| 811| IGRAPH_FINALLY_CLEAN(4); 218| | 219| 811| return IGRAPH_SUCCESS; 220| 811|} cattributes.c:igraph_i_cattribute_destroy: 222| 811|static void igraph_i_cattribute_destroy(igraph_t *graph) { 223| 811| igraph_i_cattributes_t *attr = graph->attr; 224| 811| igraph_attribute_record_list_destroy(&attr->eal); 225| 811| igraph_attribute_record_list_destroy(&attr->val); 226| 811| igraph_attribute_record_list_destroy(&attr->gal); 227| 811| IGRAPH_FREE(graph->attr); /* sets to NULL */ ------------------ | | 41| 811|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 228| 811|} cattributes.c:igraph_i_cattribute_add_vertices: 374| 1.62k|) { 375| 1.62k| igraph_i_cattributes_t *attr = graph->attr; 376| 1.62k| return igraph_i_cattribute_add_vertices_or_edges(&attr->val, igraph_vcount(graph), nv, nattr); 377| 1.62k|} cattributes.c:igraph_i_cattribute_add_vertices_or_edges: 345| 2.06k|) { 346| 2.06k| igraph_integer_t origlen = newlen - nv; 347| 2.06k| igraph_error_t err = igraph_i_cattribute_add_vertices_or_edges_inner( 348| 2.06k| val, newlen, nv, nattr 349| 2.06k| ); 350| | 351| 2.06k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (351:9): [True: 138, False: 1.92k] ------------------ 352| | /* If unsuccessful, revert attribute vector sizes. 353| | * The following function assumes that all attributes vectors that 354| | * are present have a length at least as great as origlen. 355| | * This is true at the moment because any new attributes that are 356| | * added to the graph are created directly at 'origlen' instead of 357| | * being created at smaller sizes and resized later. 358| | * 359| | * NOTE: While this ensures that all attribute vector lengths are 360| | * correct, it does not ensure that no extra attributes have 361| | * been added to the graph. However, the presence of extra 362| | * attributes does not make the attribute table inconsistent 363| | * like the incorrect attribute vector lengths would. 364| | */ 365| 138| igraph_i_cattribute_revert_attribute_vector_sizes(val, origlen); 366| 138| } 367| | 368| 2.06k| return err; 369| 2.06k|} cattributes.c:igraph_i_cattribute_add_vertices_or_edges_inner: 270| 2.06k|) { 271| 2.06k| igraph_integer_t length; 272| 2.06k| igraph_integer_t nattrno = nattr == NULL ? 0 : igraph_attribute_record_list_size(nattr); ------------------ | Branch (272:32): [True: 1.77k, False: 288] ------------------ 273| 2.06k| igraph_integer_t origlen = newlen - nv; 274| | 275| 2.06k| IGRAPH_ASSERT(origlen >= 0); ------------------ | | 916| 2.06k| do { \ | | 917| 2.06k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 2.06k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.06k] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 2.06k| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 276| | 277| | /* Find all the attributes that are newly added, and create new value vectors 278| | * for them in the original graph */ 279| 2.35k| for (igraph_integer_t i = 0; i < nattrno; i++) { ------------------ | Branch (279:34): [True: 288, False: 2.06k] ------------------ 280| 288| const igraph_attribute_record_t *nattr_entry = igraph_attribute_record_list_get_ptr(nattr, i); 281| 288| const char *nname = nattr_entry->name; 282| 288| IGRAPH_CHECK(igraph_i_cattribute_find_or_create(val, nname, nattr_entry->type, origlen, NULL)); ------------------ | | 648| 288| do { \ | | 649| 288| igraph_error_t igraph_i_ret = (expr); \ | | 650| 288| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 288| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 283| 288| } 284| | 285| | /* Now append the new values */ 286| 2.06k| length = igraph_attribute_record_list_size(val); 287| 2.21k| for (igraph_integer_t i = 0; i < length; i++) { ------------------ | Branch (287:34): [True: 288, False: 1.92k] ------------------ 288| 288| igraph_attribute_record_t *oldrec = igraph_attribute_record_list_get_ptr(val, i); 289| 288| const igraph_attribute_record_t *newrec = nattr ------------------ | Branch (289:51): [True: 288, False: 0] ------------------ 290| 288| ? igraph_i_cattribute_find_const(nattr, oldrec->name, oldrec->type) 291| 288| : NULL; 292| | 293| 288| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == origlen); ------------------ | | 916| 288| do { \ | | 917| 288| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 288| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 294| | 295| 288| if (newrec) { ------------------ | Branch (295:13): [True: 288, False: 0] ------------------ 296| | /* This attribute is present in nattr */ 297| 288| switch (oldrec->type) { 298| 117| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (298:13): [True: 117, False: 171] ------------------ 299| 117| if (nv != igraph_vector_size(newrec->value.as_vector)) { ------------------ | Branch (299:21): [True: 0, False: 117] ------------------ 300| 0| IGRAPH_ERROR("Invalid numeric attribute length.", IGRAPH_EINVAL); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 301| 0| } 302| 117| IGRAPH_CHECK(igraph_vector_append( ------------------ | | 648| 117| do { \ | | 649| 117| igraph_error_t igraph_i_ret = (expr); \ | | 650| 117| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 117| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 117] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 117| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 303| 117| oldrec->value.as_vector, newrec->value.as_vector 304| 117| )); 305| 117| break; 306| 171| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (306:13): [True: 171, False: 117] ------------------ 307| 171| if (nv != igraph_strvector_size(newrec->value.as_strvector)) { ------------------ | Branch (307:21): [True: 138, False: 33] ------------------ 308| 138| IGRAPH_ERROR("Invalid string attribute length.", IGRAPH_EINVAL); ------------------ | | 431| 138| do { \ | | 432| 138| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 138| return igraph_errno ; \ | | 434| 138| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 309| 138| } 310| 33| IGRAPH_CHECK(igraph_strvector_append( ------------------ | | 648| 33| do { \ | | 649| 33| igraph_error_t igraph_i_ret = (expr); \ | | 650| 33| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 33] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 33| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 311| 33| oldrec->value.as_strvector, newrec->value.as_strvector 312| 33| )); 313| 33| break; 314| 33| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (314:13): [True: 0, False: 288] ------------------ 315| 0| if (nv != igraph_vector_bool_size(newrec->value.as_vector_bool)) { ------------------ | Branch (315:21): [True: 0, False: 0] ------------------ 316| 0| IGRAPH_ERROR("Invalid boolean attribute length.", IGRAPH_EINVAL); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 317| 0| } 318| 0| IGRAPH_CHECK(igraph_vector_bool_append( ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 319| 0| oldrec->value.as_vector_bool, newrec->value.as_vector_bool 320| 0| )); 321| 0| break; 322| 0| default: ------------------ | Branch (322:13): [True: 0, False: 288] ------------------ 323| 0| IGRAPH_WARNINGF( ------------------ | | 769| 0| do { \ | | 770| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 771| 0| __VA_ARGS__); \ | | 772| 0| } while (0) | | ------------------ | | | Branch (772:14): [Folded - Ignored] | | ------------------ ------------------ 324| 0| "Attribute '%s' with unknown type %d ignored", 325| 0| oldrec->name, (int) oldrec->type 326| 0| ); 327| 0| break; 328| 288| } 329| 288| } else { 330| | /* No such attribute among the new ones so just extend the length 331| | * of the current record */ 332| 0| IGRAPH_CHECK(igraph_attribute_record_resize(oldrec, newlen)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 333| 0| } 334| | 335| 150| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == newlen); ------------------ | | 916| 150| do { \ | | 917| 150| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 150| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 150] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 150| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 336| 150| } 337| | 338| 1.92k| return IGRAPH_SUCCESS; 339| 2.06k|} cattributes.c:igraph_i_cattribute_find_const: 91| 288|) { 92| 288| igraph_integer_t index = igraph_i_cattribute_find_index(attrs, name); 93| 288| const igraph_attribute_record_t *rec; 94| | 95| 288| if (index >= 0) { ------------------ | Branch (95:9): [True: 288, False: 0] ------------------ 96| 288| rec = igraph_attribute_record_list_get_ptr(attrs, index); 97| 288| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) { ------------------ | Branch (97:13): [True: 0, False: 288] | Branch (97:53): [True: 288, False: 0] ------------------ 98| 288| return rec; 99| 288| } 100| 288| } 101| | 102| 0| return NULL; 103| 288|} cattributes.c:igraph_i_cattribute_revert_attribute_vector_sizes: 180| 138| igraph_attribute_record_list_t *attrlist, igraph_integer_t origlen) { 181| | 182| 138| igraph_integer_t no_of_attrs = igraph_attribute_record_list_size(attrlist); 183| 276| for (igraph_integer_t i = 0; i < no_of_attrs; i++) { ------------------ | Branch (183:34): [True: 138, False: 138] ------------------ 184| 138| igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrlist, i); 185| 138| IGRAPH_ASSERT(igraph_attribute_record_size(rec) >= origlen); ------------------ | | 916| 138| do { \ | | 917| 138| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 604| 138| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 138] | | | | ------------------ | | ------------------ | | 918| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 919| 0| } \ | | 920| 138| } while (0) | | ------------------ | | | Branch (920:14): [Folded - Ignored] | | ------------------ ------------------ 186| 138| if (igraph_attribute_record_resize(rec, origlen) != IGRAPH_SUCCESS) { ------------------ | Branch (186:13): [True: 0, False: 138] ------------------ 187| | /* We should have succeeded for known attribute types because we 188| | * always shrink the vector so throw a fatal error if this happens */ 189| 0| IGRAPH_FATAL("Unknown attribute type encountered."); ------------------ | | 887| 0| do { \ | | 888| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 889| 0| } while (0) | | ------------------ | | | Branch (889:14): [Folded - Ignored] | | ------------------ ------------------ 190| 0| } 191| 138| } 192| 138|} cattributes.c:igraph_i_cattribute_add_edges: 1480| 445|) { 1481| 445| igraph_integer_t ne = igraph_vector_int_size(edges) / 2; 1482| 445| igraph_i_cattributes_t *attr = graph->attr; 1483| 445| return igraph_i_cattribute_add_vertices_or_edges(&attr->eal, igraph_ecount(graph), ne, nattr); 1484| 445|} cattributes.c:igraph_i_cattribute_find: 70| 288|) { 71| 288| igraph_integer_t index = igraph_i_cattribute_find_index(attrs, name); 72| 288| igraph_attribute_record_t *rec; 73| | 74| 288| if (index >= 0) { ------------------ | Branch (74:9): [True: 0, False: 288] ------------------ 75| 0| rec = igraph_attribute_record_list_get_ptr(attrs, index); 76| 0| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) { ------------------ | Branch (76:13): [True: 0, False: 0] | Branch (76:53): [True: 0, False: 0] ------------------ 77| 0| return rec; 78| 0| } 79| 0| } 80| | 81| 288| return NULL; 82| 288|} cattributes.c:igraph_i_cattribute_find_or_create: 148| 288|) { 149| 288| igraph_attribute_record_t *rec; 150| | 151| 288| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED); 152| 288| if (rec) { ------------------ | Branch (152:9): [True: 0, False: 288] ------------------ 153| 0| if (type != IGRAPH_ATTRIBUTE_UNSPECIFIED) { ------------------ | Branch (153:13): [True: 0, False: 0] ------------------ 154| 0| IGRAPH_CHECK(igraph_attribute_record_check_type(rec, type)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 155| 0| } 156| 288| } else { 157| 288| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(attrs, &rec)); ------------------ | | 648| 288| do { \ | | 649| 288| igraph_error_t igraph_i_ret = (expr); \ | | 650| 288| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 288| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 158| 288| IGRAPH_CHECK(igraph_attribute_record_set_name(rec, name)); ------------------ | | 648| 288| do { \ | | 649| 288| igraph_error_t igraph_i_ret = (expr); \ | | 650| 288| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 288| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 159| 288| IGRAPH_CHECK(igraph_attribute_record_set_type(rec, type)); ------------------ | | 648| 288| do { \ | | 649| 288| igraph_error_t igraph_i_ret = (expr); \ | | 650| 288| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 288] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 288| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 160| 288| } 161| | 162| 288| if (length > 0 && igraph_attribute_record_size(rec) < length) { ------------------ | Branch (162:9): [True: 0, False: 288] | Branch (162:23): [True: 0, False: 0] ------------------ 163| 0| IGRAPH_CHECK(igraph_attribute_record_resize(rec, length)); ------------------ | | 648| 0| do { \ | | 649| 0| igraph_error_t igraph_i_ret = (expr); \ | | 650| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 0| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 164| 0| } 165| | 166| 288| if (ptr) { ------------------ | Branch (166:9): [True: 0, False: 288] ------------------ 167| 0| *ptr = rec; 168| 0| } 169| | 170| 288| return IGRAPH_SUCCESS; 171| 288|} cattributes.c:igraph_i_cattribute_find_index: 50| 576|) { 51| 576| igraph_integer_t n = igraph_attribute_record_list_size(attrs); 52| 576| for (igraph_integer_t i = 0; i < n; i++) { ------------------ | Branch (52:34): [True: 288, False: 288] ------------------ 53| 288| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrs, i); 54| 288| if (!strcmp(rec->name, name)) { ------------------ | Branch (54:13): [True: 288, False: 0] ------------------ 55| 288| return i; 56| 288| } 57| 288| } 58| 288| return -1; 59| 576|} igraph_empty: 65| 811|igraph_error_t igraph_empty(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed) { 66| 811| return igraph_empty_attrs(graph, n, directed, 0); 67| 811|} igraph_empty_attrs: 101| 811|) { 102| | 103| 811| if (n < 0) { ------------------ | Branch (103:9): [True: 0, False: 811] ------------------ 104| 0| IGRAPH_ERROR("Number of vertices must not be negative.", IGRAPH_EINVAL); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 105| 0| } 106| | 107| 811| memset(graph, 0, sizeof(igraph_t)); 108| | 109| 811| graph->n = 0; 110| 811| graph->directed = directed; 111| 811| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0); ------------------ | | 124| 811| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 811| do { \ | | | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 811] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 811| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 811| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 811| do { \ | | | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 811| * incorrect destructor function with the pointer */ \ | | | | 595| 811| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 811| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 112| 811| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0); ------------------ | | 124| 811| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 811| do { \ | | | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 811] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 811| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 811| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 811| do { \ | | | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 811| * incorrect destructor function with the pointer */ \ | | | | 595| 811| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 811| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 113| 811| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0); ------------------ | | 124| 811| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 811| do { \ | | | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 811] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 811| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 811| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 811| do { \ | | | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 811| * incorrect destructor function with the pointer */ \ | | | | 595| 811| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 811| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 114| 811| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0); ------------------ | | 124| 811| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 811| do { \ | | | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 811] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 811| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 811| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 811| do { \ | | | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 811| * incorrect destructor function with the pointer */ \ | | | | 595| 811| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 811| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 115| 811| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1); ------------------ | | 124| 811| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 811| do { \ | | | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 811] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 811| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 811| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 811| do { \ | | | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 811| * incorrect destructor function with the pointer */ \ | | | | 595| 811| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 811| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 116| 811| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1); ------------------ | | 124| 811| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 811| do { \ | | | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 811] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 811| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 811| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 811| do { \ | | | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 811| * incorrect destructor function with the pointer */ \ | | | | 595| 811| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 811| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 117| | 118| | /* init cache */ 119| 811| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t); ------------------ | | 38| 811|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 1.62k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [Folded - Ignored] | | | | | Branch (36:24): [Folded - Ignored] | | | | | Branch (36:66): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 120| 811| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph."); ------------------ | | 701| 811| do { \ | | 702| 811| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 811| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 121| 811| IGRAPH_FINALLY(igraph_free, graph->cache); ------------------ | | 591| 811| do { \ | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 811| * incorrect destructor function with the pointer */ \ | | 595| 811| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 811| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 122| 811| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 123| 811| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache); ------------------ | | 591| 811| do { \ | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 811| * incorrect destructor function with the pointer */ \ | | 595| 811| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 811| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 124| | 125| 811| VECTOR(graph->os)[0] = 0; ------------------ | | 65| 811|#define VECTOR(v) ((v).stor_begin) ------------------ 126| 811| VECTOR(graph->is)[0] = 0; ------------------ | | 65| 811|#define VECTOR(v) ((v).stor_begin) ------------------ 127| | 128| | /* init attributes */ 129| 811| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 130| | 131| | /* add the vertices */ 132| 811| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 133| | 134| 811| IGRAPH_FINALLY_CLEAN(8); 135| 811| return IGRAPH_SUCCESS; 136| 811|} igraph_destroy: 154| 811|void igraph_destroy(igraph_t *graph) { 155| 811| igraph_i_attribute_destroy(graph); 156| | 157| 811| igraph_i_property_cache_destroy(graph->cache); 158| 811| IGRAPH_FREE(graph->cache); ------------------ | | 41| 811|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 159| | 160| 811| igraph_vector_int_destroy(&graph->from); 161| 811| igraph_vector_int_destroy(&graph->to); 162| 811| igraph_vector_int_destroy(&graph->oi); 163| 811| igraph_vector_int_destroy(&graph->ii); 164| 811| igraph_vector_int_destroy(&graph->os); 165| 811| igraph_vector_int_destroy(&graph->is); 166| 811|} igraph_add_edges: 256| 673|) { 257| 673| igraph_integer_t no_of_edges = igraph_vector_int_size(&graph->from); 258| 673| igraph_integer_t edges_to_add = igraph_vector_int_size(edges) / 2; 259| 673| igraph_integer_t new_no_of_edges; 260| 673| igraph_integer_t i = 0; 261| 673| igraph_vector_int_t newoi, newii; 262| 673| igraph_bool_t directed = igraph_is_directed(graph); 263| | 264| 673| if (igraph_vector_int_size(edges) % 2 != 0) { ------------------ | Branch (264:9): [True: 0, False: 673] ------------------ 265| 0| IGRAPH_ERROR("Invalid (odd) length of edges vector.", IGRAPH_EINVAL); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 266| 0| } 267| 673| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) { ------------------ | Branch (267:9): [True: 228, False: 445] ------------------ 268| 228| IGRAPH_ERROR("Out-of-range vertex IDs when adding edges.", IGRAPH_EINVVID); ------------------ | | 431| 228| do { \ | | 432| 228| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 228| return igraph_errno ; \ | | 434| 228| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 269| 228| } 270| | 271| | /* from & to */ 272| 445| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges); ------------------ | | 47| 445| do { \ | | 48| 445| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 445| igraph_integer_t _safe_sum; \ | | 50| 445| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 445] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 469| 0| do { \ | | | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 472| 0| return igraph_errno; \ | | | | 473| 0| } while (0) | | | | ------------------ | | | | | Branch (473:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 445| *(res) = _safe_sum; \ | | 54| 445| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 273| 445| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) { ------------------ | | 121| 445|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2) | | ------------------ | | | | 77| 445|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (273:9): [True: 0, False: 445] ------------------ 274| 0| IGRAPH_ERRORF("Maximum edge count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE, ------------------ | | 469| 0| do { \ | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | 472| 0| return igraph_errno; \ | | 473| 0| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 275| 0| IGRAPH_ECOUNT_MAX); 276| 0| } 277| 445| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add)); ------------------ | | 648| 445| do { \ | | 649| 445| igraph_error_t igraph_i_ret = (expr); \ | | 650| 445| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 445| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 445] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 445| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 278| 445| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add)); ------------------ | | 648| 445| do { \ | | 649| 445| igraph_error_t igraph_i_ret = (expr); \ | | 650| 445| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 445| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 445] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 445| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 279| | 280| 2.58M| while (i < edges_to_add * 2) { ------------------ | Branch (280:12): [True: 2.57M, False: 445] ------------------ 281| 2.57M| if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) { ------------------ | | 65| 0|#define VECTOR(v) ((v).stor_begin) ------------------ if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) { ------------------ | | 65| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (281:13): [True: 2.57M, False: 0] | Branch (281:25): [True: 0, False: 0] ------------------ 282| 2.57M| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 65| 2.57M|#define VECTOR(v) ((v).stor_begin) ------------------ 283| 2.57M| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 65| 2.57M|#define VECTOR(v) ((v).stor_begin) ------------------ 284| 2.57M| } else { 285| 0| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 65| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 286| 0| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 65| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 287| 0| } 288| 2.57M| } 289| | 290| | /* If an error occurs while the edges are being added, we make the necessary fixup 291| | * to ensure that the graph is still in a consistent state when this function returns. 292| | * The graph may already be on the finally stack when calling this function. We use 293| | * a separate finally stack level to avoid its destructor from being called on error, 294| | * so that the fixup can succeed. 295| | */ 296| | 297| 445|#define CHECK_ERR(expr) \ 298| 445| do { \ 299| 445| igraph_error_t err = (expr); \ 300| 445| if (err != IGRAPH_SUCCESS) { \ 301| 445| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ 302| 445| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ 303| 445| IGRAPH_FINALLY_EXIT(); \ 304| 445| IGRAPH_ERROR("Cannot add edges.", err); \ 305| 445| } \ 306| 445| } while (0) 307| | 308| | /* oi & ii */ 309| 445| IGRAPH_FINALLY_ENTER(); 310| 445| { 311| 445| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges)); ------------------ | | 298| 445| do { \ | | 299| 445| igraph_error_t err = (expr); \ | | 300| 445| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (300:13): [True: 0, False: 445] | | ------------------ | | 301| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 302| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| IGRAPH_FINALLY_EXIT(); \ | | 304| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 305| 0| } \ | | 306| 445| } while (0) | | ------------------ | | | Branch (306:14): [Folded - Ignored] | | ------------------ ------------------ 312| 445| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi); ------------------ | | 591| 445| do { \ | | 592| 445| /* the following branch makes the compiler check the compatibility of \ | | 593| 445| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 445| * incorrect destructor function with the pointer */ \ | | 595| 445| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 445| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 445| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 313| 445| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges)); ------------------ | | 298| 445| do { \ | | 299| 445| igraph_error_t err = (expr); \ | | 300| 445| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (300:13): [True: 0, False: 445] | | ------------------ | | 301| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 302| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| IGRAPH_FINALLY_EXIT(); \ | | 304| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 305| 0| } \ | | 306| 445| } while (0) | | ------------------ | | | Branch (306:14): [Folded - Ignored] | | ------------------ ------------------ 314| 445| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii); ------------------ | | 591| 445| do { \ | | 592| 445| /* the following branch makes the compiler check the compatibility of \ | | 593| 445| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 445| * incorrect destructor function with the pointer */ \ | | 595| 445| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 445| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 445| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 315| 445| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n)); ------------------ | | 298| 445| do { \ | | 299| 445| igraph_error_t err = (expr); \ | | 300| 445| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (300:13): [True: 0, False: 445] | | ------------------ | | 301| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 302| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| IGRAPH_FINALLY_EXIT(); \ | | 304| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 305| 0| } \ | | 306| 445| } while (0) | | ------------------ | | | Branch (306:14): [Folded - Ignored] | | ------------------ ------------------ 316| 445| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n)); ------------------ | | 298| 445| do { \ | | 299| 445| igraph_error_t err = (expr); \ | | 300| 445| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (300:13): [True: 0, False: 445] | | ------------------ | | 301| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 302| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| IGRAPH_FINALLY_EXIT(); \ | | 304| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 305| 0| } \ | | 306| 445| } while (0) | | ------------------ | | | Branch (306:14): [Folded - Ignored] | | ------------------ ------------------ 317| | 318| | /* Attributes */ 319| 445| if (graph->attr) { ------------------ | Branch (319:13): [True: 445, False: 0] ------------------ 320| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */ 321| 445| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr)); ------------------ | | 298| 445| do { \ | | 299| 445| igraph_error_t err = (expr); \ | | 300| 445| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (300:13): [True: 0, False: 445] | | ------------------ | | 301| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 302| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| IGRAPH_FINALLY_EXIT(); \ | | 304| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 305| 0| } \ | | 306| 445| } while (0) | | ------------------ | | | Branch (306:14): [Folded - Ignored] | | ------------------ ------------------ 322| 445| } 323| | 324| | /* os & is, its length does not change, error safe */ 325| 445| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n); 326| 445| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n); 327| | 328| | /* everything went fine */ 329| 445| igraph_vector_int_destroy(&graph->oi); 330| 445| igraph_vector_int_destroy(&graph->ii); 331| 445| IGRAPH_FINALLY_CLEAN(2); 332| | 333| 445| graph->oi = newoi; 334| 445| graph->ii = newii; 335| 445| } 336| 0| IGRAPH_FINALLY_EXIT(); 337| | 338| 445|#undef CHECK_ERR 339| | 340| | /* modification successful, clear the cached properties of the graph. 341| | * 342| | * Adding one or more edges cannot make a strongly or weakly connected 343| | * graph disconnected, so we keep those flags if they are cached as true. 344| | * 345| | * Adding one or more edges may turn a DAG into a non-DAG or a forest into 346| | * a non-forest, so we can keep those flags only if they are cached as 347| | * false. 348| | * 349| | * Also, adding one or more edges does not change HAS_LOOP, HAS_MULTI and 350| | * HAS_MUTUAL if they were already true. 351| | */ 352| 445| igraph_i_property_cache_invalidate_conditionally( 353| 445| graph, 354| 445| /* keep_always = */ 0, 355| | /* keep_when_false = */ 356| 445| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST), 357| | /* keep_when_true = */ 358| 445| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) | 359| 445| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 360| 445| (1 << IGRAPH_PROP_HAS_LOOP) | 361| 445| (1 << IGRAPH_PROP_HAS_MULTI) | 362| 445| (1 << IGRAPH_PROP_HAS_MUTUAL) 363| 445| ); 364| | 365| 445| return IGRAPH_SUCCESS; 366| 445|} igraph_add_vertices: 390| 1.62k|) { 391| 1.62k| igraph_integer_t ec = igraph_ecount(graph); 392| 1.62k| igraph_integer_t vc = igraph_vcount(graph); 393| 1.62k| igraph_integer_t new_vc; 394| 1.62k| igraph_integer_t i; 395| | 396| 1.62k| if (nv < 0) { ------------------ | Branch (396:9): [True: 0, False: 1.62k] ------------------ 397| 0| IGRAPH_ERROR("Cannot add negative number of vertices.", IGRAPH_EINVAL); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 398| 0| } 399| | 400| 1.62k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc); ------------------ | | 47| 1.62k| do { \ | | 48| 1.62k| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 1.62k| igraph_integer_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); \ | | ------------------ | | | | 469| 0| do { \ | | | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 472| 0| return igraph_errno; \ | | | | 473| 0| } while (0) | | | | ------------------ | | | | | Branch (473:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 1.62k| *(res) = _safe_sum; \ | | 54| 1.62k| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 401| 1.62k| if (new_vc > IGRAPH_VCOUNT_MAX) { ------------------ | | 105| 1.62k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1) | | ------------------ | | | | 77| 1.62k|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (401:9): [True: 0, False: 1.62k] ------------------ 402| 0| IGRAPH_ERRORF("Maximum vertex count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE, ------------------ | | 469| 0| do { \ | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | 472| 0| return igraph_errno; \ | | 473| 0| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 403| 0| IGRAPH_VCOUNT_MAX); 404| 0| } 405| 1.62k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1)); ------------------ | | 648| 1.62k| do { \ | | 649| 1.62k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 1.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 1.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.62k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 1.62k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 406| 1.62k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1)); ------------------ | | 648| 1.62k| do { \ | | 649| 1.62k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 1.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 1.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 1.62k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 1.62k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 407| | 408| 1.62k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */ 409| 1.62k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */ 410| 123M| for (i = graph->n + 1; i < new_vc + 1; i++) { ------------------ | Branch (410:28): [True: 123M, False: 1.62k] ------------------ 411| 123M| VECTOR(graph->os)[i] = ec; ------------------ | | 65| 123M|#define VECTOR(v) ((v).stor_begin) ------------------ 412| 123M| VECTOR(graph->is)[i] = ec; ------------------ | | 65| 123M|#define VECTOR(v) ((v).stor_begin) ------------------ 413| 123M| } 414| | 415| 1.62k| graph->n += nv; 416| | 417| | /* Add attributes if necessary. This section is protected with 418| | * FINALLY_ENTER/EXIT so that the graph would not be accidentally 419| | * free upon error until it could be restored to a consistant state. */ 420| | 421| 1.62k| if (graph->attr) { ------------------ | Branch (421:9): [True: 1.62k, False: 0] ------------------ 422| 1.62k| igraph_error_t err; 423| 1.62k| IGRAPH_FINALLY_ENTER(); 424| 1.62k| err = igraph_i_attribute_add_vertices(graph, nv, attr); 425| 1.62k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (425:13): [True: 138, False: 1.48k] ------------------ 426| | /* Restore original vertex count on failure */ 427| 138| graph->n = vc; 428| 138| igraph_vector_int_resize(&graph->os, vc + 1); /* shrinks */ 429| 138| igraph_vector_int_resize(&graph->is, vc + 1); /* shrinks */ 430| 138| } 431| 1.62k| IGRAPH_FINALLY_EXIT(); 432| 1.62k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (432:13): [True: 138, False: 1.48k] ------------------ 433| 138| IGRAPH_ERROR("Cannot add vertices.", err); ------------------ | | 431| 138| do { \ | | 432| 138| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 138| return igraph_errno ; \ | | 434| 138| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 434| 138| } 435| 1.62k| } 436| | 437| | /* modification successful, clear the cached properties of the graph. 438| | * 439| | * Adding one or more nodes does not change the following cached properties: 440| | * 441| | * - IGRAPH_PROP_HAS_LOOP 442| | * - IGRAPH_PROP_HAS_MULTI 443| | * - IGRAPH_PROP_HAS_MUTUAL 444| | * - IGRAPH_PROP_IS_DAG (adding a node does not create/destroy cycles) 445| | * - IGRAPH_PROP_IS_FOREST (same) 446| | * 447| | * Adding one or more nodes without any edges incident on them is sure to 448| | * make the graph disconnected (weakly or strongly), so we can keep the 449| | * connectivity-related properties if they are currently cached as false. 450| | * (Actually, even if they weren't cached as false, we could still set them 451| | * to false, but we don't have that functionality yet). The only exception 452| | * is when the graph had zero vertices and gained only one vertex, because 453| | * it then becomes connected. That's why we have the condition below in the 454| | * keep_when_false section. 455| | */ 456| 1.48k| igraph_i_property_cache_invalidate_conditionally( 457| 1.48k| graph, 458| | /* keep_always = */ 459| 1.48k| (1 << IGRAPH_PROP_HAS_LOOP) | 460| 1.48k| (1 << IGRAPH_PROP_HAS_MULTI) | 461| 1.48k| (1 << IGRAPH_PROP_HAS_MUTUAL) | 462| 1.48k| (1 << IGRAPH_PROP_IS_DAG) | 463| 1.48k| (1 << IGRAPH_PROP_IS_FOREST), 464| | /* keep_when_false = */ 465| 1.48k| igraph_vcount(graph) >= 2 ? ( ------------------ | Branch (465:9): [True: 626, False: 858] ------------------ 466| 626| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 467| 626| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) 468| 858| ) : 0, 469| | /* keep_when_true = */ 470| 1.48k| 0 471| 1.48k| ); 472| | 473| 1.48k| return IGRAPH_SUCCESS; 474| 1.62k|} igraph_vcount: 828| 5.40k|igraph_integer_t igraph_vcount(const igraph_t *graph) { 829| 5.40k| return graph->n; 830| 5.40k|} igraph_ecount: 842| 2.06k|igraph_integer_t igraph_ecount(const igraph_t *graph) { 843| 2.06k| return igraph_vector_int_size(&graph->from); 844| 2.06k|} igraph_is_directed: 1108| 673|igraph_bool_t igraph_is_directed(const igraph_t *graph) { 1109| 673| return graph->directed; 1110| 673|} type_indexededgelist.c:igraph_i_create_start_vectors: 1051| 890| igraph_vector_int_t *iindex, igraph_integer_t nodes) { 1052| | 1053| 890|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) 1054| | 1055| 890| igraph_integer_t no_of_nodes; 1056| 890| igraph_integer_t no_of_edges; 1057| 890| igraph_integer_t i, j, idx; 1058| | 1059| 890| no_of_nodes = nodes; 1060| 890| no_of_edges = igraph_vector_int_size(el); 1061| | 1062| | /* result */ 1063| | 1064| 890| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1)); ------------------ | | 648| 890| do { \ | | 649| 890| igraph_error_t igraph_i_ret = (expr); \ | | 650| 890| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 890| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 890] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 890| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 1065| | 1066| | /* create the index */ 1067| | 1068| 890| if (no_of_edges == 0) { ------------------ | Branch (1068:9): [True: 276, False: 614] ------------------ 1069| | /* empty graph */ 1070| 276| igraph_vector_int_null(res); 1071| 614| } else { 1072| 614| idx = -1; 1073| 4.11M| for (i = 0; i <= EDGE(0); i++) { ------------------ | | 1053| 4.11M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 65| 4.11M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 65| 4.11M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (1073:21): [True: 4.11M, False: 614] ------------------ 1074| 4.11M| idx++; VECTOR(*res)[idx] = 0; ------------------ | | 65| 4.11M|#define VECTOR(v) ((v).stor_begin) ------------------ 1075| 4.11M| } 1076| 5.15M| for (i = 1; i < no_of_edges; i++) { ------------------ | Branch (1076:21): [True: 5.15M, False: 614] ------------------ 1077| 5.15M| igraph_integer_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1053| 5.15M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ igraph_integer_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1053| 5.15M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 65| 5.15M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1078| 8.29M| for (j = 0; j < n; j++) { ------------------ | Branch (1078:25): [True: 3.13M, False: 5.15M] ------------------ 1079| 3.13M| idx++; VECTOR(*res)[idx] = i; ------------------ | | 65| 3.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 1080| 3.13M| } 1081| 5.15M| } 1082| 614| j = EDGE(VECTOR(*res)[idx]); ------------------ | | 1053| 614|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 65| 614|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 65| 614|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1083| 18.9M| for (i = 0; i < no_of_nodes - j; i++) { ------------------ | Branch (1083:21): [True: 18.9M, False: 614] ------------------ 1084| 18.9M| idx++; VECTOR(*res)[idx] = no_of_edges; ------------------ | | 65| 18.9M|#define VECTOR(v) ((v).stor_begin) ------------------ 1085| 18.9M| } 1086| 614| } 1087| | 1088| | /* clean */ 1089| | 1090| 890|# undef EDGE 1091| 890| return IGRAPH_SUCCESS; 1092| 890|} igraph_dl_yylex_destroy_wrapper: 38| 1.89k|void igraph_dl_yylex_destroy_wrapper (void *scanner ) { 39| 1.89k| (void) igraph_dl_yylex_destroy(scanner); 40| 1.89k|} igraph_read_graph_dl: 69| 2.33k| igraph_bool_t directed) { 70| | 71| 2.33k| igraph_integer_t n, n2; 72| 2.33k| const igraph_strvector_t *namevec = 0; 73| 2.33k| igraph_attribute_record_list_t name, weight; 74| 2.33k| igraph_attribute_record_list_t *pname = NULL; 75| 2.33k| igraph_attribute_record_list_t *pweight = NULL; 76| 2.33k| igraph_attribute_record_t *namerec, *weightrec; 77| 2.33k| const char *namestr = "name", *weightstr = "weight"; 78| 2.33k| igraph_i_dl_parsedata_t context; 79| | 80| 2.33k| context.eof = 0; 81| 2.33k| context.mode = 0; 82| 2.33k| context.n = -1; 83| 2.33k| context.from = 0; 84| 2.33k| context.to = 0; 85| 2.33k| context.errmsg[0] = '\0'; 86| 2.33k| context.igraph_errno = IGRAPH_SUCCESS; 87| | 88| 2.33k| IGRAPH_VECTOR_INT_INIT_FINALLY(&context.edges, 0); ------------------ | | 124| 2.33k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 648| 2.33k| do { \ | | | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 2.33k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 591| 2.33k| do { \ | | | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 595| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 89| 2.33k| IGRAPH_VECTOR_INIT_FINALLY(&context.weights, 0); ------------------ | | 109| 2.33k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 648| 2.33k| do { \ | | | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 2.33k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 591| 2.33k| do { \ | | | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 595| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 90| 2.33k| IGRAPH_CHECK(igraph_strvector_init(&context.labels, 0)); ------------------ | | 648| 2.33k| do { \ | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 2.33k| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 91| 2.33k| IGRAPH_FINALLY(igraph_strvector_destroy, &context.labels); ------------------ | | 591| 2.33k| do { \ | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | 595| 2.33k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 2.33k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 92| 2.33k| IGRAPH_TRIE_INIT_FINALLY(&context.trie, /*names=*/ 1); ------------------ | | 56| 2.33k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \ | | ------------------ | | | | 648| 2.33k| do { \ | | | | 649| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 650| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 604| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (604:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 431| 0| do { \ | | | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 433| 0| return igraph_errno ; \ | | | | | | 434| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (434:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 652| 0| } \ | | | | 653| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (653:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 57| 2.33k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0) | | ------------------ | | | | 591| 2.33k| do { \ | | | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 595| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (595:13): [Folded - Ignored] | | | | ------------------ | | | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 597| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (597:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (57:59): [Folded - Ignored] | | ------------------ ------------------ 93| | 94| 2.33k| igraph_dl_yylex_init_extra(&context, &context.scanner); 95| 2.33k| IGRAPH_FINALLY(igraph_dl_yylex_destroy_wrapper, context.scanner); ------------------ | | 591| 2.33k| do { \ | | 592| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | 593| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 2.33k| * incorrect destructor function with the pointer */ \ | | 595| 2.33k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 2.33k| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 96| | 97| 2.33k| igraph_dl_yyset_in(instream, context.scanner); 98| | 99| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */ 100| 2.33k| IGRAPH_FINALLY_ENTER(); 101| 2.33k| int err = igraph_dl_yyparse(&context); 102| 2.33k| IGRAPH_FINALLY_EXIT(); 103| 2.33k| switch (err) { 104| 811| case 0: /* success */ ------------------ | Branch (104:5): [True: 811, False: 1.52k] ------------------ 105| 811| break; 106| 1.52k| case 1: /* parse error */ ------------------ | Branch (106:5): [True: 1.52k, False: 811] ------------------ 107| 1.52k| if (context.errmsg[0] != 0) { ------------------ | Branch (107:13): [True: 1.47k, False: 48] ------------------ 108| 1.47k| IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR); ------------------ | | 431| 1.47k| do { \ | | 432| 1.47k| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 1.47k| return igraph_errno ; \ | | 434| 1.47k| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 109| 1.47k| } else if (context.igraph_errno != IGRAPH_SUCCESS) { ------------------ | Branch (109:20): [True: 48, False: 0] ------------------ 110| 48| IGRAPH_ERROR("", context.igraph_errno); ------------------ | | 431| 48| do { \ | | 432| 48| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 48| return igraph_errno ; \ | | 434| 48| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 111| 48| } else { 112| 0| IGRAPH_ERROR("Cannot read DL file.", IGRAPH_PARSEERROR); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 113| 0| } 114| 0| break; 115| 0| case 2: /* out of memory */ ------------------ | Branch (115:5): [True: 0, False: 2.33k] ------------------ 116| 0| IGRAPH_ERROR("Cannot read DL file.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 117| 0| break; 118| 0| default: /* must never reach here */ ------------------ | Branch (118:5): [True: 0, False: 2.33k] ------------------ 119| | /* Hint: This will usually be triggered if an IGRAPH_CHECK() is used in a Bison 120| | * action instead of an IGRAPH_YY_CHECK(), resulting in an igraph errno being 121| | * returned in place of a Bison error code. 122| | * TODO: What if future Bison versions introduce error codes other than 0, 1 and 2? 123| | */ 124| 0| IGRAPH_FATALF("Parser returned unexpected error code (%d) when reading DL file.", err); ------------------ | | 867| 0| do { \ | | 868| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 869| 0| __VA_ARGS__); \ | | 870| 0| } while (0) | | ------------------ | | | Branch (870:14): [Folded - Ignored] | | ------------------ ------------------ 125| 2.33k| } 126| | 127| | /* Extend the weight vector, if needed */ 128| 811| n = igraph_vector_size(&context.weights); 129| 811| n2 = igraph_vector_int_size(&context.edges) / 2; 130| 811| if (n != 0) { ------------------ | Branch (130:9): [True: 223, False: 588] ------------------ 131| 223| IGRAPH_CHECK(igraph_vector_resize(&context.weights, n2)); ------------------ | | 648| 223| do { \ | | 649| 223| igraph_error_t igraph_i_ret = (expr); \ | | 650| 223| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 223| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 223] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 223| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 132| 10.4k| for (; n < n2; n++) { ------------------ | Branch (132:16): [True: 10.2k, False: 223] ------------------ 133| 10.2k| VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 65| 10.2k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 143| 10.2k|#define IGRAPH_NAN ((double)NAN) ------------------ 134| 10.2k| } 135| 223| } 136| | 137| | /* Check number of vertices */ 138| 811| if (n2 > 0) { ------------------ | Branch (138:9): [True: 600, False: 211] ------------------ 139| 600| n = igraph_vector_int_max(&context.edges); 140| 600| } else { 141| 211| n = 0; 142| 211| } 143| 811| if (n >= context.n) { ------------------ | Branch (143:9): [True: 346, False: 465] ------------------ 144| 346| IGRAPH_WARNING("More vertices than specified in `DL' file"); ------------------ | | 789| 346| do { \ | | 790| 346| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 791| 346| } while (0) | | ------------------ | | | Branch (791:14): [Folded - Ignored] | | ------------------ ------------------ 145| 346| context.n = n; 146| 346| } 147| | 148| | /* Prepare attributes */ 149| | 150| | /* Labels */ 151| 811| if (igraph_strvector_size(&context.labels) != 0) { ------------------ | Branch (151:9): [True: 94, False: 717] ------------------ 152| 94| namevec = (const igraph_strvector_t*) &context.labels; 153| 717| } else if (igraph_trie_size(&context.trie) != 0) { ------------------ | Branch (153:16): [True: 77, False: 640] ------------------ 154| 77| namevec = igraph_i_trie_borrow_keys(&context.trie); 155| 77| } 156| 811| if (namevec) { ------------------ | Branch (156:9): [True: 171, False: 640] ------------------ 157| 171| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1)); ------------------ | | 648| 171| do { \ | | 649| 171| igraph_error_t igraph_i_ret = (expr); \ | | 650| 171| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 171| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 171] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 171| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 158| 171| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name); ------------------ | | 591| 171| do { \ | | 592| 171| /* the following branch makes the compiler check the compatibility of \ | | 593| 171| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 171| * incorrect destructor function with the pointer */ \ | | 595| 171| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 171| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 171| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 159| | 160| 171| namerec = igraph_attribute_record_list_get_ptr(&name, 0); 161| 171| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr)); ------------------ | | 648| 171| do { \ | | 649| 171| igraph_error_t igraph_i_ret = (expr); \ | | 650| 171| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 171| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 171] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 171| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 162| 171| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING)); ------------------ | | 648| 171| do { \ | | 649| 171| igraph_error_t igraph_i_ret = (expr); \ | | 650| 171| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 171| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 171] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 171| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 163| 171| IGRAPH_CHECK(igraph_strvector_update(namerec->value.as_strvector, namevec)); ------------------ | | 648| 171| do { \ | | 649| 171| igraph_error_t igraph_i_ret = (expr); \ | | 650| 171| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 171| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 171] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 171| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 164| | 165| 171| pname = &name; 166| 171| } 167| | 168| | /* Weights */ 169| 811| if (igraph_vector_size(&context.weights) != 0) { ------------------ | Branch (169:9): [True: 223, False: 588] ------------------ 170| 223| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1)); ------------------ | | 648| 223| do { \ | | 649| 223| igraph_error_t igraph_i_ret = (expr); \ | | 650| 223| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 223| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 223] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 223| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 171| 223| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight); ------------------ | | 591| 223| do { \ | | 592| 223| /* the following branch makes the compiler check the compatibility of \ | | 593| 223| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 223| * incorrect destructor function with the pointer */ \ | | 595| 223| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 223| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 223| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 172| | 173| 223| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0); 174| 223| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr)); ------------------ | | 648| 223| do { \ | | 649| 223| igraph_error_t igraph_i_ret = (expr); \ | | 650| 223| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 223| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 223] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 223| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 175| 223| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC)); ------------------ | | 648| 223| do { \ | | 649| 223| igraph_error_t igraph_i_ret = (expr); \ | | 650| 223| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 223| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 223] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 223| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 176| 223| igraph_vector_swap(weightrec->value.as_vector, &context.weights); 177| | 178| 223| pweight = &weight; 179| 223| } 180| | 181| | /* Create graph */ 182| 811| IGRAPH_CHECK(igraph_empty(graph, 0, directed)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 811] | | | | ------------------ | | ------------------ | | 651| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 0| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 183| 811| IGRAPH_FINALLY(igraph_destroy, graph); ------------------ | | 591| 811| do { \ | | 592| 811| /* the following branch makes the compiler check the compatibility of \ | | 593| 811| * func and ptr to detect cases when we are accidentally invoking an \ | | 594| 811| * incorrect destructor function with the pointer */ \ | | 595| 811| if (0) { func(ptr); } \ | | ------------------ | | | Branch (595:13): [Folded - Ignored] | | ------------------ | | 596| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 597| 811| } while (0) | | ------------------ | | | Branch (597:14): [Folded - Ignored] | | ------------------ ------------------ 184| 811| IGRAPH_CHECK(igraph_add_vertices(graph, context.n, pname)); ------------------ | | 648| 811| do { \ | | 649| 811| igraph_error_t igraph_i_ret = (expr); \ | | 650| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 138, False: 673] | | | | ------------------ | | ------------------ | | 651| 138| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 138| do { \ | | | | 432| 138| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 138| return igraph_errno ; \ | | | | 434| 138| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 138| } \ | | 653| 811| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 185| 673| IGRAPH_CHECK(igraph_add_edges(graph, &context.edges, pweight)); ------------------ | | 648| 673| do { \ | | 649| 673| igraph_error_t igraph_i_ret = (expr); \ | | 650| 673| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 604| 673| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 228, False: 445] | | | | ------------------ | | ------------------ | | 651| 228| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 431| 228| do { \ | | | | 432| 228| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 228| return igraph_errno ; \ | | | | 434| 228| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 652| 228| } \ | | 653| 673| } while (0) | | ------------------ | | | Branch (653:14): [Folded - Ignored] | | ------------------ ------------------ 186| | 187| 445| if (pweight) { ------------------ | Branch (187:9): [True: 117, False: 328] ------------------ 188| 117| igraph_attribute_record_list_destroy(pweight); 189| 117| IGRAPH_FINALLY_CLEAN(1); 190| 117| } 191| | 192| 445| if (pname) { ------------------ | Branch (192:9): [True: 33, False: 412] ------------------ 193| 33| igraph_attribute_record_list_destroy(pname); 194| 33| IGRAPH_FINALLY_CLEAN(1); 195| 33| } 196| | 197| | /* don't destroy the graph itself but pop it from the finally stack */ 198| 445| IGRAPH_FINALLY_CLEAN(1); 199| | 200| 445| igraph_trie_destroy(&context.trie); 201| 445| igraph_strvector_destroy(&context.labels); 202| 445| igraph_vector_int_destroy(&context.edges); 203| 445| igraph_vector_destroy(&context.weights); 204| 445| igraph_dl_yylex_destroy(context.scanner); 205| 445| IGRAPH_FINALLY_CLEAN(5); 206| | 207| 445| return IGRAPH_SUCCESS; 208| 673|} igraph_i_parse_integer: 52| 5.91M|igraph_error_t igraph_i_parse_integer(const char *str, size_t length, igraph_integer_t *value) { 53| 5.91M| char buffer[128]; 54| 5.91M| char *tmp, *end; 55| 5.91M| char last_char; 56| 5.91M| igraph_bool_t out_of_range, dynamic_alloc; 57| 5.91M| long long val; 58| | 59| 5.91M| if (length == 0) { ------------------ | Branch (59:9): [True: 0, False: 5.91M] ------------------ 60| 0| IGRAPH_ERROR("Cannot parse integer from empty string.", IGRAPH_PARSEERROR); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 61| 0| } 62| | 63| 5.91M| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]); 64| | 65| 5.91M| if (dynamic_alloc) { ------------------ | Branch (65:9): [True: 217, False: 5.91M] ------------------ 66| 217| tmp = IGRAPH_CALLOC(length+1, char); ------------------ | | 38| 217|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 434| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 217, False: 0] | | | | | Branch (36:24): [True: 217, False: 0] | | | | | Branch (36:66): [True: 217, False: 0] | | | | ------------------ | | ------------------ ------------------ 67| 217| IGRAPH_CHECK_OOM(tmp, "Failed to parse integer."); ------------------ | | 701| 217| do { \ | | 702| 217| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 217| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 217] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 217| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 68| 5.91M| } else { 69| 5.91M| tmp = buffer; 70| 5.91M| } 71| | 72| 5.91M| strncpy(tmp, str, length); 73| 5.91M| tmp[length]='\0'; 74| | 75| | /* To avoid having to choose the appropriate strto?() function based on 76| | * the definition of igraph_integer_t, we first use a long long variable 77| | * which should be at least as large as igraph_integer_t on any platform. */ 78| 5.91M| errno = 0; 79| 5.91M| val = strtoll(tmp, &end, 10); 80| 5.91M| out_of_range = errno == ERANGE; 81| 5.91M| *value = (igraph_integer_t) val; 82| 5.91M| last_char = *end; 83| 5.91M| if (*value != val) { ------------------ | Branch (83:9): [True: 0, False: 5.91M] ------------------ 84| 0| out_of_range = true; 85| 0| } 86| | 87| | /* Free memory before raising any errors. */ 88| 5.91M| if (dynamic_alloc) { ------------------ | Branch (88:9): [True: 217, False: 5.91M] ------------------ 89| 217| IGRAPH_FREE(tmp); ------------------ | | 41| 217|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 90| 217| } 91| | 92| 5.91M| if (out_of_range) { ------------------ | Branch (92:9): [True: 36, False: 5.91M] ------------------ 93| 36| IGRAPH_ERROR("Failed to parse integer.", val > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 431| 36| do { \ | | 432| 72| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (432:63): [True: 35, False: 1] | | ------------------ | | 433| 72| return igraph_errno ; \ | | ------------------ | | | Branch (433:16): [True: 35, False: 1] | | ------------------ | | 434| 36| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 94| 36| } 95| | 96| | /* Did we parse to the end of the string? */ 97| 5.91M| if (last_char) { ------------------ | Branch (97:9): [True: 2, False: 5.91M] ------------------ 98| 2| IGRAPH_ERRORF("Unexpected character '%c' while parsing integer.", IGRAPH_PARSEERROR, last_char); ------------------ | | 469| 2| do { \ | | 470| 2| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 2| igraph_errno, __VA_ARGS__) ; \ | | 472| 2| return igraph_errno; \ | | 473| 2| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 99| 2| } 100| | 101| 5.91M| return IGRAPH_SUCCESS; 102| 5.91M|} igraph_i_parse_real: 113| 317k|igraph_error_t igraph_i_parse_real(const char *str, size_t length, igraph_real_t *value) { 114| 317k| char buffer[128]; 115| 317k| char *tmp, *end; 116| 317k| char last_char; 117| 317k| igraph_bool_t out_of_range, dynamic_alloc; 118| | 119| 317k| if (length == 0) { ------------------ | Branch (119:9): [True: 0, False: 317k] ------------------ 120| 0| IGRAPH_ERROR("Cannot parse real number from empty string.", IGRAPH_PARSEERROR); ------------------ | | 431| 0| do { \ | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 433| 0| return igraph_errno ; \ | | 434| 0| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 121| 0| } 122| | 123| 317k| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]); 124| | 125| 317k| if (dynamic_alloc) { ------------------ | Branch (125:9): [True: 218, False: 317k] ------------------ 126| 218| tmp = IGRAPH_CALLOC(length+1, char); ------------------ | | 38| 218|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 36| 436| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (36:12): [True: 218, False: 0] | | | | | Branch (36:24): [True: 218, False: 0] | | | | | Branch (36:66): [True: 218, False: 0] | | | | ------------------ | | ------------------ ------------------ 127| 218| IGRAPH_CHECK_OOM(tmp, "Failed to parse real number."); ------------------ | | 701| 218| do { \ | | 702| 218| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 604| 218| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (604:32): [True: 0, False: 218] | | | | ------------------ | | ------------------ | | 703| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 431| 0| do { \ | | | | 432| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 433| 0| return igraph_errno ; \ | | | | 434| 0| } while (0) | | | | ------------------ | | | | | Branch (434:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 704| 0| } \ | | 705| 218| } while (0) | | ------------------ | | | Branch (705:14): [Folded - Ignored] | | ------------------ ------------------ 128| 317k| } else { 129| 317k| tmp = buffer; 130| 317k| } 131| | 132| 317k| strncpy(tmp, str, length); 133| 317k| tmp[length]='\0'; 134| | 135| 317k| errno = 0; 136| 317k| *value = strtod(tmp, &end); 137| 317k| out_of_range = errno == ERANGE; /* This does not trigger when reading +-Inf. */ 138| 317k| last_char = *end; 139| | 140| | /* Free memory before raising any errors. */ 141| 317k| if (dynamic_alloc) { ------------------ | Branch (141:9): [True: 218, False: 317k] ------------------ 142| 218| IGRAPH_FREE(tmp); ------------------ | | 41| 218|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 143| 218| } 144| | 145| 317k| if (out_of_range) { ------------------ | Branch (145:9): [True: 25, False: 317k] ------------------ 146| 25| IGRAPH_ERROR("Failed to parse real number.", *value > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 431| 25| do { \ | | 432| 50| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (432:63): [True: 15, False: 10] | | ------------------ | | 433| 50| return igraph_errno ; \ | | ------------------ | | | Branch (433:16): [True: 15, False: 10] | | ------------------ | | 434| 25| } while (0) | | ------------------ | | | Branch (434:14): [Folded - Ignored] | | ------------------ ------------------ 147| 25| } 148| | 149| | /* Did we parse to the end of the string? */ 150| 317k| if (last_char) { ------------------ | Branch (150:9): [True: 0, False: 317k] ------------------ 151| 0| IGRAPH_ERRORF("Unexpected character '%c' while parsing real number.", IGRAPH_PARSEERROR, last_char); ------------------ | | 469| 0| do { \ | | 470| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 471| 0| igraph_errno, __VA_ARGS__) ; \ | | 472| 0| return igraph_errno; \ | | 473| 0| } while (0) | | ------------------ | | | Branch (473:14): [Folded - Ignored] | | ------------------ ------------------ 152| 0| } 153| | 154| 317k| return IGRAPH_SUCCESS; 155| 317k|}