igraph_dl_yylex: 1152| 11.0M|{ 1153| 11.0M| yy_state_type yy_current_state; 1154| 11.0M| char *yy_cp, *yy_bp; 1155| 11.0M| int yy_act; 1156| 11.0M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1157| | 1158| 11.0M| yylval = yylval_param; ------------------ | | 965| 11.0M| # define yylval yyg->yylval_r ------------------ 1159| | 1160| 11.0M| yylloc = yylloc_param; ------------------ | | 967| 11.0M| # define yylloc yyg->yylloc_r ------------------ 1161| | 1162| 11.0M| if ( !yyg->yy_init ) ------------------ | Branch (1162:7): [True: 2.45k, False: 11.0M] ------------------ 1163| 2.45k| { 1164| 2.45k| yyg->yy_init = 1; 1165| | 1166| |#ifdef YY_USER_INIT 1167| | YY_USER_INIT; 1168| |#endif 1169| | 1170| 2.45k| if ( ! yyg->yy_start ) ------------------ | Branch (1170:8): [True: 2.45k, False: 0] ------------------ 1171| 2.45k| yyg->yy_start = 1; /* first start state */ 1172| | 1173| 2.45k| if ( ! yyin ) ------------------ | | 356| 2.45k|#define yyin yyg->yyin_r ------------------ | Branch (1173:8): [True: 0, False: 2.45k] ------------------ 1174| 0| yyin = stdin; ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 1175| | 1176| 2.45k| if ( ! yyout ) ------------------ | | 357| 2.45k|#define yyout yyg->yyout_r ------------------ | Branch (1176:8): [True: 2.45k, False: 0] ------------------ 1177| 2.45k| yyout = stdout; ------------------ | | 357| 2.45k|#define yyout yyg->yyout_r ------------------ 1178| | 1179| 2.45k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 521| 2.45k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 0, False: 2.45k] | | ------------------ | | 522| 2.45k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.45k| : NULL) ------------------ | Branch (1179:8): [True: 2.45k, False: 0] ------------------ 1180| 2.45k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 2.45k|#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack ------------------ 1181| 2.45k| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 527| 2.45k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1182| 2.45k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 2.45k|#define yy_create_buffer igraph_dl_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 2.45k|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 2.45k|#define YY_BUF_SIZE 16384 ------------------ 1183| 2.45k| } 1184| | 1185| 2.45k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.45k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1186| 2.45k| } 1187| | 1188| 11.0M| { 1189| 11.0M|#line 81 "/src/igraph/src/io/dl-lexer.l" 1190| | 1191| | 1192| 11.0M|#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| 57.4M| { 1210| 57.4M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 57.4M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1211| 57.4M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1211:9): [True: 48.4M, False: 8.98M] ------------------ 1212| 48.4M| { 1213| 48.4M| yyg->yy_last_accepting_state = yy_current_state; 1214| 48.4M| yyg->yy_last_accepting_cpos = yy_cp; 1215| 48.4M| } 1216| 93.6M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1216:12): [True: 36.2M, False: 57.4M] ------------------ 1217| 36.2M| { 1218| 36.2M| yy_current_state = (int) yy_def[yy_current_state]; 1219| 36.2M| if ( yy_current_state >= 129 ) ------------------ | Branch (1219:10): [True: 22.9M, False: 13.2M] ------------------ 1220| 22.9M| yy_c = yy_meta[yy_c]; 1221| 36.2M| } 1222| 57.4M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1223| 57.4M| ++yy_cp; 1224| 57.4M| } 1225| 57.4M| while ( yy_base[yy_current_state] != 493 ); ------------------ | Branch (1225:11): [True: 40.2M, 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: 13.2M, False: 3.95M] ------------------ 1230| 13.2M| { /* have to back up */ 1231| 13.2M| yy_cp = yyg->yy_last_accepting_cpos; 1232| 13.2M| yy_current_state = yyg->yy_last_accepting_state; 1233| 13.2M| yy_act = yy_accept[yy_current_state]; 1234| 13.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: 12.9k] | Branch (1238:38): [True: 2.72M, False: 14.4M] ------------------ 1239| 2.72M| { 1240| 2.72M| int yyl; 1241| 5.45M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 359| 5.45M|#define yyleng yyg->yyleng_r ------------------ | Branch (1241:19): [True: 2.72M, False: 2.72M] ------------------ 1242| 2.72M| if ( yytext[yyl] == '\n' ) ------------------ | | 360| 2.72M|#define yytext yyg->yytext_r ------------------ | Branch (1242:10): [True: 2.71M, False: 10.5k] ------------------ 1243| | 1244| 2.71M| do{ yylineno++; ------------------ | | 361| 2.71M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 527| 2.71M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1245| 2.71M| yycolumn=0; ------------------ | | 362| 2.71M|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 527| 2.71M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1246| 2.71M| }while(0) ------------------ | Branch (1246:12): [Folded - Ignored] ------------------ 1247| 2.72M|; 1248| 2.72M| } 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.72M|case 1: ------------------ | Branch (1261:1): [True: 2.72M, False: 14.4M] ------------------ 1262| |/* rule 1 can match eol */ 1263| 2.72M|YY_RULE_SETUP ------------------ | | 1147| 2.72M| YY_USER_ACTION | | ------------------ | | | | 891| 2.72M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.72M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.72M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.72M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1264| 2.72M|#line 83 "/src/igraph/src/io/dl-lexer.l" 1265| 2.72M|{ return NEWLINE; } 1266| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1267| 2.30k|case 2: ------------------ | Branch (1267:1): [True: 2.30k, False: 17.1M] ------------------ 1268| 2.30k|YY_RULE_SETUP ------------------ | | 1147| 2.30k| YY_USER_ACTION | | ------------------ | | | | 891| 2.30k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.30k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.30k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1269| 2.30k|#line 85 "/src/igraph/src/io/dl-lexer.l" 1270| 2.30k|{ return DL; } 1271| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1272| 2.29k|case 3: ------------------ | Branch (1272:1): [True: 2.29k, False: 17.1M] ------------------ 1273| 2.29k|YY_RULE_SETUP ------------------ | | 1147| 2.29k| YY_USER_ACTION | | ------------------ | | | | 891| 2.29k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.29k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.29k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1274| 2.29k|#line 86 "/src/igraph/src/io/dl-lexer.l" 1275| 2.29k|{ return NEQ; } 1276| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1277| 2.30k|case 4: ------------------ | Branch (1277:1): [True: 2.30k, False: 17.1M] ------------------ 1278| 2.30k|YY_RULE_SETUP ------------------ | | 1147| 2.30k| YY_USER_ACTION | | ------------------ | | | | 891| 2.30k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.30k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.30k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1279| 2.30k|#line 87 "/src/igraph/src/io/dl-lexer.l" 1280| 2.30k|{ return NUM; } 1281| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1282| 2.14k|case 5: ------------------ | Branch (1282:1): [True: 2.14k, False: 17.1M] ------------------ 1283| 2.14k|YY_RULE_SETUP ------------------ | | 1147| 2.14k| YY_USER_ACTION | | ------------------ | | | | 891| 2.14k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.14k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.14k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1284| 2.14k|#line 89 "/src/igraph/src/io/dl-lexer.l" 1285| 2.14k|{ 1286| 2.14k| switch (yyextra->mode) { ------------------ | | 358| 2.14k|#define yyextra yyg->yyextra_r ------------------ | Branch (1286:11): [True: 0, False: 2.14k] ------------------ 1287| 528| case 0: BEGIN(FULLMATRIX); ------------------ | | 369| 528|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 0: BEGIN(FULLMATRIX); ------------------ | | 907| 528|#define FULLMATRIX 2 ------------------ | Branch (1287:3): [True: 528, False: 1.61k] ------------------ 1288| 528| break; 1289| 1.01k| case 1: BEGIN(EDGELIST); ------------------ | | 369| 1.01k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 1: BEGIN(EDGELIST); ------------------ | | 908| 1.01k|#define EDGELIST 3 ------------------ | Branch (1289:3): [True: 1.01k, False: 1.13k] ------------------ 1290| 1.01k| break; 1291| 602| case 2: BEGIN(NODELIST); ------------------ | | 369| 602|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 2: BEGIN(NODELIST); ------------------ | | 909| 602|#define NODELIST 4 ------------------ | Branch (1291:3): [True: 602, False: 1.54k] ------------------ 1292| 602| break; 1293| 2.14k| } 1294| 2.14k| return DATA; } 1295| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1296| 338|case 6: ------------------ | Branch (1296:1): [True: 338, False: 17.1M] ------------------ 1297| 338|YY_RULE_SETUP ------------------ | | 1147| 338| YY_USER_ACTION | | ------------------ | | | | 891| 338|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 338| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 338|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 338|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1298| 338|#line 100 "/src/igraph/src/io/dl-lexer.l" 1299| 338|{ BEGIN(LABELM); return LABELS; } ------------------ | | 369| 338|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(LABELM); return LABELS; } ------------------ | | 906| 338|#define LABELM 1 ------------------ 1300| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1301| 428|case 7: ------------------ | Branch (1301:1): [True: 428, False: 17.1M] ------------------ 1302| 428|YY_RULE_SETUP ------------------ | | 1147| 428| YY_USER_ACTION | | ------------------ | | | | 891| 428|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 428| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 428|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 428|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1303| 428|#line 101 "/src/igraph/src/io/dl-lexer.l" 1304| 428|{ 1305| 428| 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.03k|case 9: ------------------ | Branch (1313:1): [True: 1.03k, False: 17.1M] ------------------ 1314| 1.03k|YY_RULE_SETUP ------------------ | | 1147| 1.03k| YY_USER_ACTION | | ------------------ | | | | 891| 1.03k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.03k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.03k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1315| 1.03k|#line 105 "/src/igraph/src/io/dl-lexer.l" 1316| 1.03k|{ 1317| 1.03k| yyextra->mode=1; return FORMATEDGELIST1; } ------------------ | | 358| 1.03k|#define yyextra yyg->yyextra_r ------------------ 1318| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1319| 623|case 10: ------------------ | Branch (1319:1): [True: 623, False: 17.1M] ------------------ 1320| 623|YY_RULE_SETUP ------------------ | | 1147| 623| YY_USER_ACTION | | ------------------ | | | | 891| 623|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 623| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 623|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 623|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1321| 623|#line 107 "/src/igraph/src/io/dl-lexer.l" 1322| 623|{ 1323| 623| yyextra->mode=2; return FORMATNODELIST1; } ------------------ | | 358| 623|#define yyextra yyg->yyextra_r ------------------ 1324| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1325| 3.27k|case 11: ------------------ | Branch (1325:1): [True: 3.27k, False: 17.1M] ------------------ 1326| 3.27k|YY_RULE_SETUP ------------------ | | 1147| 3.27k| YY_USER_ACTION | | ------------------ | | | | 891| 3.27k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 3.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 3.27k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 3.27k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1327| 3.27k|#line 110 "/src/igraph/src/io/dl-lexer.l" 1328| 3.27k|{ /* eaten up */ } 1329| 3.27k| YY_BREAK ------------------ | | 1143| 3.27k|#define YY_BREAK /*LINTED*/break; ------------------ 1330| 1.81M|case 12: ------------------ | Branch (1330:1): [True: 1.81M, False: 15.3M] ------------------ 1331| 1.81M|YY_RULE_SETUP ------------------ | | 1147| 1.81M| YY_USER_ACTION | | ------------------ | | | | 891| 1.81M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.81M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.81M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.81M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1332| 1.81M|#line 111 "/src/igraph/src/io/dl-lexer.l" 1333| 1.81M|{ return LABEL; } 1334| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1335| 2.35M|case 13: ------------------ | Branch (1335:1): [True: 2.35M, False: 14.8M] ------------------ 1336| 2.35M|YY_RULE_SETUP ------------------ | | 1147| 2.35M| YY_USER_ACTION | | ------------------ | | | | 891| 2.35M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.35M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.35M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.35M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1337| 2.35M|#line 113 "/src/igraph/src/io/dl-lexer.l" 1338| 2.35M|{ return DIGIT; } 1339| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1340| 1.44k|case 14: ------------------ | Branch (1340:1): [True: 1.44k, False: 17.1M] ------------------ 1341| 1.44k|YY_RULE_SETUP ------------------ | | 1147| 1.44k| YY_USER_ACTION | | ------------------ | | | | 891| 1.44k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.44k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.44k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1342| 1.44k|#line 114 "/src/igraph/src/io/dl-lexer.l" 1343| 1.44k|{ return LABEL; } 1344| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1345| 3.94M|case 15: ------------------ | Branch (1345:1): [True: 3.94M, False: 13.2M] ------------------ 1346| 3.94M|YY_RULE_SETUP ------------------ | | 1147| 3.94M| YY_USER_ACTION | | ------------------ | | | | 891| 3.94M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 3.94M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 3.94M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 3.94M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1347| 3.94M|#line 115 "/src/igraph/src/io/dl-lexer.l" 1348| 3.94M|{ } 1349| 3.94M| YY_BREAK ------------------ | | 1143| 3.94M|#define YY_BREAK /*LINTED*/break; ------------------ 1350| 4.03M|case 16: ------------------ | Branch (1350:1): [True: 4.03M, False: 13.1M] ------------------ 1351| 4.03M|YY_RULE_SETUP ------------------ | | 1147| 4.03M| YY_USER_ACTION | | ------------------ | | | | 891| 4.03M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 4.03M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 4.03M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 4.03M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1352| 4.03M|#line 117 "/src/igraph/src/io/dl-lexer.l" 1353| 4.03M|{ return NUM; } 1354| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1355| 1.75k|case 17: ------------------ | Branch (1355:1): [True: 1.75k, False: 17.1M] ------------------ 1356| 1.75k|YY_RULE_SETUP ------------------ | | 1147| 1.75k| YY_USER_ACTION | | ------------------ | | | | 891| 1.75k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.75k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.75k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1357| 1.75k|#line 118 "/src/igraph/src/io/dl-lexer.l" 1358| 1.75k|{ return LABEL; } 1359| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1360| 2.05M|case 18: ------------------ | Branch (1360:1): [True: 2.05M, False: 15.1M] ------------------ 1361| 2.05M|YY_RULE_SETUP ------------------ | | 1147| 2.05M| YY_USER_ACTION | | ------------------ | | | | 891| 2.05M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 2.05M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.05M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.05M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1362| 2.05M|#line 119 "/src/igraph/src/io/dl-lexer.l" 1363| 2.05M|{ } 1364| 2.05M| YY_BREAK ------------------ | | 1143| 2.05M|#define YY_BREAK /*LINTED*/break; ------------------ 1365| 1.29k|case 19: ------------------ | Branch (1365:1): [True: 1.29k, False: 17.1M] ------------------ 1366| 1.29k|YY_RULE_SETUP ------------------ | | 1147| 1.29k| YY_USER_ACTION | | ------------------ | | | | 891| 1.29k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 1.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.29k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.29k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1367| 1.29k|#line 121 "/src/igraph/src/io/dl-lexer.l" 1368| 1.29k|{ return NUM; } 1369| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1370| 127k|case 20: ------------------ | Branch (1370:1): [True: 127k, False: 17.0M] ------------------ 1371| 127k|YY_RULE_SETUP ------------------ | | 1147| 127k| YY_USER_ACTION | | ------------------ | | | | 891| 127k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 127k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 127k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 127k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1372| 127k|#line 122 "/src/igraph/src/io/dl-lexer.l" 1373| 127k|{ return LABEL; } 1374| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1375| 107k|case 21: ------------------ | Branch (1375:1): [True: 107k, False: 17.0M] ------------------ 1376| 107k|YY_RULE_SETUP ------------------ | | 1147| 107k| YY_USER_ACTION | | ------------------ | | | | 891| 107k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 107k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 107k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 107k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1377| 107k|#line 123 "/src/igraph/src/io/dl-lexer.l" 1378| 107k|{ } 1379| 107k| YY_BREAK ------------------ | | 1143| 107k|#define YY_BREAK /*LINTED*/break; ------------------ 1380| 79|case 22: ------------------ | Branch (1380:1): [True: 79, False: 17.1M] ------------------ 1381| 79|YY_RULE_SETUP ------------------ | | 1147| 79| YY_USER_ACTION | | ------------------ | | | | 891| 79|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 79| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 79|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 79|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1382| 79|#line 125 "/src/igraph/src/io/dl-lexer.l" 1383| 79|{ /* eaten up */ } 1384| 79| YY_BREAK ------------------ | | 1143| 79|#define YY_BREAK /*LINTED*/break; ------------------ 1385| 919|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 919|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 919|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1385:1): [True: 919, False: 17.1M] ------------------ 1386| 988|case YY_STATE_EOF(LABELM): ------------------ | | 377| 988|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 988|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1386:1): [True: 69, False: 17.1M] ------------------ 1387| 1.45k|case YY_STATE_EOF(FULLMATRIX): ------------------ | | 377| 1.45k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.45k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1387:1): [True: 468, False: 17.1M] ------------------ 1388| 1.93k|case YY_STATE_EOF(EDGELIST): ------------------ | | 377| 1.93k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.93k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1388:1): [True: 476, False: 17.1M] ------------------ 1389| 2.39k|case YY_STATE_EOF(NODELIST): ------------------ | | 377| 2.39k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.39k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1389:1): [True: 466, False: 17.1M] ------------------ 1390| 2.39k|#line 127 "/src/igraph/src/io/dl-lexer.l" 1391| 2.39k|{ 1392| 2.39k| if (yyextra->eof) { ------------------ | | 358| 2.39k|#define yyextra yyg->yyextra_r ------------------ | Branch (1392:31): [True: 873, False: 1.52k] ------------------ 1393| 873| yyterminate(); ------------------ | | 1106| 873|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 873|#define YY_NULL 0 | | ------------------ ------------------ 1394| 1.52k| } else { 1395| 1.52k| yyextra->eof=1; ------------------ | | 358| 1.52k|#define yyextra yyg->yyextra_r ------------------ 1396| 1.52k| BEGIN(INITIAL); ------------------ | | 369| 1.52k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 905| 1.52k|#define INITIAL 0 ------------------ 1397| 1.52k| return EOFF; 1398| 1.52k| } 1399| 2.39k| } 1400| 0| YY_BREAK ------------------ | | 1143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1401| 142|case 23: ------------------ | Branch (1401:1): [True: 142, False: 17.1M] ------------------ 1402| 142|YY_RULE_SETUP ------------------ | | 1147| 142| YY_USER_ACTION | | ------------------ | | | | 891| 142|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 967| 142| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 142|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 142|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1403| 142|#line 137 "/src/igraph/src/io/dl-lexer.l" 1404| 142|{ 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) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080: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| 12.9k| case YY_END_OF_BUFFER: ------------------ | | 594| 12.9k|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1413:2): [True: 12.9k, False: 17.1M] ------------------ 1414| 12.9k| { 1415| | /* Amount of text matched not including the EOB char. */ 1416| 12.9k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 577| 12.9k|#define yytext_ptr yytext_r ------------------ 1417| | 1418| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1419| 12.9k| *yy_cp = yyg->yy_hold_char; 1420| 12.9k| YY_RESTORE_YY_MORE_OFFSET 1421| | 1422| 12.9k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 527| 12.9k|#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| 12.9k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1422:8): [True: 3.32k, False: 9.63k] ------------------ 1423| 3.32k| { 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.32k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 3.32k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1434| 3.32k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 527| 3.32k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 3.32k|#define yyin yyg->yyin_r ------------------ 1435| 3.32k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 527| 3.32k|#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.32k|#define YY_BUFFER_NORMAL 1 ------------------ 1436| 3.32k| } 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| 12.9k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 527| 12.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1445:8): [True: 200, False: 12.7k] ------------------ 1446| 200| { /* This was really a NUL. */ 1447| 200| yy_state_type yy_next_state; 1448| | 1449| 200| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 200|#define yytext_ptr yytext_r ------------------ 1450| | 1451| 200| 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| 200| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1463| | 1464| 200| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 200|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 200|#define YY_MORE_ADJ 0 ------------------ 1465| | 1466| 200| if ( yy_next_state ) ------------------ | Branch (1466:9): [True: 67, False: 133] ------------------ 1467| 67| { 1468| | /* Consume the NUL. */ 1469| 67| yy_cp = ++yyg->yy_c_buf_p; 1470| 67| yy_current_state = yy_next_state; 1471| 67| goto yy_match; 1472| 67| } 1473| | 1474| 133| else 1475| 133| { 1476| 133| yy_cp = yyg->yy_c_buf_p; 1477| 133| goto yy_find_action; 1478| 133| } 1479| 200| } 1480| | 1481| 12.7k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1481:17): [True: 0, False: 12.7k] ------------------ 1482| 12.7k| { 1483| 2.39k| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 2.39k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1483:4): [True: 2.39k, False: 10.3k] ------------------ 1484| 2.39k| { 1485| 2.39k| yyg->yy_did_buffer_switch_on_eof = 0; 1486| | 1487| 2.39k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 2.39k|#define yywrap igraph_dl_yywrap | | ------------------ | | | | 571| 2.39k|#define igraph_dl_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (571:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1488| 2.39k| { 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.39k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.39k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.39k|#define YY_MORE_ADJ 0 ------------------ 1499| | 1500| 2.39k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 2.39k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.39k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ 1501| 2.39k| goto do_action; 1502| 2.39k| } 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.39k| } 1511| | 1512| 8.15k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 8.15k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1512:4): [True: 8.15k, False: 4.61k] ------------------ 1513| 8.15k| yyg->yy_c_buf_p = 1514| 8.15k| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 8.15k|#define yytext_ptr yytext_r ------------------ 1515| | 1516| 8.15k| yy_current_state = yy_get_previous_state( yyscanner ); 1517| | 1518| 8.15k| yy_cp = yyg->yy_c_buf_p; 1519| 8.15k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 8.15k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 8.15k|#define YY_MORE_ADJ 0 ------------------ 1520| 8.15k| goto yy_match; 1521| | 1522| 2.21k| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 2.21k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1522:4): [True: 2.21k, False: 10.5k] ------------------ 1523| 2.21k| yyg->yy_c_buf_p = 1524| 2.21k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 527| 2.21k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1525| | 1526| 2.21k| yy_current_state = yy_get_previous_state( yyscanner ); 1527| | 1528| 2.21k| yy_cp = yyg->yy_c_buf_p; 1529| 2.21k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.21k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.21k|#define YY_MORE_ADJ 0 ------------------ 1530| 2.21k| goto yy_find_action; 1531| 12.7k| } 1532| 0| break; 1533| 12.9k| } 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) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080: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| 11.0M| } /* end of user's declarations */ 1541| 11.0M|} /* end of yylex */ igraph_dl_yyrestart: 1839| 2.39k|{ 1840| 2.39k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1841| | 1842| 2.39k| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 521| 2.39k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.39k, False: 0] | | ------------------ | | 522| 2.39k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.39k| : NULL) ------------------ | Branch (1842:7): [True: 0, False: 2.39k] ------------------ 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.39k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 50| 2.39k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 521| 2.39k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.39k, False: 0] | | ------------------ | | 522| 2.39k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.39k| : NULL) ------------------ 1849| 2.39k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.39k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1850| 2.39k|} igraph_dl_yy_create_buffer: 1904| 2.45k|{ 1905| 2.45k| YY_BUFFER_STATE b; 1906| | 1907| 2.45k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 2.45k|#define yyalloc igraph_dl_yyalloc ------------------ 1908| 2.45k| if ( ! b ) ------------------ | Branch (1908:7): [True: 0, False: 2.45k] ------------------ 1909| 2.45k| 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) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1910| | 1911| 2.45k| 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.45k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); ------------------ | | 236| 2.45k|#define yyalloc igraph_dl_yyalloc ------------------ 1917| 2.45k| if ( ! b->yy_ch_buf ) ------------------ | Branch (1917:7): [True: 0, False: 2.45k] ------------------ 1918| 2.45k| 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) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1919| | 1920| 2.45k| b->yy_is_our_buffer = 1; 1921| | 1922| 2.45k| yy_init_buffer( b, file , yyscanner); ------------------ | | 50| 2.45k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ 1923| | 1924| 2.45k| return b; 1925| 2.45k|} igraph_dl_yy_delete_buffer: 1932| 2.45k|{ 1933| 2.45k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1934| | 1935| 2.45k| if ( ! b ) ------------------ | Branch (1935:7): [True: 0, False: 2.45k] ------------------ 1936| 0| return; 1937| | 1938| 2.45k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 521| 2.45k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.45k, False: 0] | | ------------------ | | 522| 2.45k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.45k| : NULL) ------------------ | Branch (1938:7): [True: 2.45k, False: 0] ------------------ 1939| 2.45k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 527| 2.45k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1940| | 1941| 2.45k| if ( b->yy_is_our_buffer ) ------------------ | Branch (1941:7): [True: 2.45k, False: 0] ------------------ 1942| 2.45k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 2.45k|#define yyfree igraph_dl_yyfree ------------------ 1943| | 1944| 2.45k| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 2.45k|#define yyfree igraph_dl_yyfree ------------------ 1945| 2.45k|} igraph_dl_yy_flush_buffer: 1981| 4.85k|{ 1982| 4.85k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1983| 4.85k| if ( ! b ) ------------------ | Branch (1983:7): [True: 0, False: 4.85k] ------------------ 1984| 0| return; 1985| | 1986| 4.85k| 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.85k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.85k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1993| 4.85k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.85k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1994| | 1995| 4.85k| b->yy_buf_pos = &b->yy_ch_buf[0]; 1996| | 1997| 4.85k| b->yy_at_bol = 1; 1998| 4.85k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 498| 4.85k|#define YY_BUFFER_NEW 0 ------------------ 1999| | 2000| 4.85k| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 521| 4.85k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.85k, False: 0] | | ------------------ | | 522| 4.85k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.85k| : NULL) ------------------ | Branch (2000:7): [True: 2.39k, False: 2.45k] ------------------ 2001| 2.39k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.39k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 2002| 4.85k|} igraph_dl_yypop_buffer_state: 2042| 2.45k|{ 2043| 2.45k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2044| 2.45k| if (!YY_CURRENT_BUFFER) ------------------ | | 521| 2.45k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.45k, False: 0] | | ------------------ | | 522| 2.45k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.45k| : NULL) ------------------ | Branch (2044:6): [True: 2.45k, False: 0] ------------------ 2045| 2.45k| 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| 5.98M|{ 2280| 5.98M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2281| 5.98M| return yyleng; ------------------ | | 359| 5.98M|#define yyleng yyg->yyleng_r ------------------ 2282| 5.98M|} igraph_dl_yyget_text: 2289| 8.33M|{ 2290| 8.33M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2291| 8.33M| return yytext; ------------------ | | 360| 8.33M|#define yytext yyg->yytext_r ------------------ 2292| 8.33M|} igraph_dl_yyset_extra: 2299| 4.90k|{ 2300| 4.90k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2301| 4.90k| yyextra = user_defined ; ------------------ | | 358| 4.90k|#define yyextra yyg->yyextra_r ------------------ 2302| 4.90k|} igraph_dl_yyset_in: 2341| 2.45k|{ 2342| 2.45k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2343| 2.45k| yyin = _in_str ; ------------------ | | 356| 2.45k|#define yyin yyg->yyin_r ------------------ 2344| 2.45k|} igraph_dl_yylex_init_extra: 2424| 2.45k|{ 2425| 2.45k| struct yyguts_t dummy_yyguts; 2426| | 2427| 2.45k| yyset_extra (yy_user_defined, &dummy_yyguts); ------------------ | | 140| 2.45k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2428| | 2429| 2.45k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2429:9): [True: 0, False: 2.45k] ------------------ 2430| 0| errno = EINVAL; 2431| 0| return 1; 2432| 0| } 2433| | 2434| 2.45k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); ------------------ | | 236| 2.45k|#define yyalloc igraph_dl_yyalloc ------------------ 2435| | 2436| 2.45k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2436:9): [True: 0, False: 2.45k] ------------------ 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.45k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2444| | 2445| 2.45k| yyset_extra (yy_user_defined, *ptr_yy_globals); ------------------ | | 140| 2.45k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2446| | 2447| 2.45k| return yy_init_globals ( *ptr_yy_globals ); 2448| 2.45k|} igraph_dl_yylex_destroy: 2485| 2.45k|{ 2486| 2.45k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2487| | 2488| | /* Pop the buffer stack, destroying each element. */ 2489| 4.90k| while(YY_CURRENT_BUFFER){ ------------------ | | 521| 4.90k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:27): [True: 2.45k, False: 2.45k] | | | Branch (521:29): [True: 4.90k, False: 0] | | ------------------ | | 522| 4.90k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.90k| : NULL) ------------------ 2490| 2.45k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 2.45k|#define yy_delete_buffer igraph_dl_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 521| 2.45k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.45k, False: 0] | | ------------------ | | 522| 2.45k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.45k| : NULL) ------------------ 2491| 2.45k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 527| 2.45k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2492| 2.45k| yypop_buffer_state(yyscanner); ------------------ | | 80| 2.45k|#define yypop_buffer_state igraph_dl_yypop_buffer_state ------------------ 2493| 2.45k| } 2494| | 2495| | /* Destroy the stack itself. */ 2496| 2.45k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 2.45k|#define yyfree igraph_dl_yyfree ------------------ 2497| 2.45k| yyg->yy_buffer_stack = NULL; 2498| | 2499| | /* Destroy the start condition stack. */ 2500| 2.45k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 2.45k|#define yyfree igraph_dl_yyfree ------------------ 2501| 2.45k| 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.45k| yy_init_globals( yyscanner); 2506| | 2507| | /* Destroy the main struct (reentrant only). */ 2508| 2.45k| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 2.45k|#define yyfree igraph_dl_yyfree ------------------ 2509| 2.45k| yyscanner = NULL; 2510| 2.45k| return 0; 2511| 2.45k|} igraph_dl_yyalloc: 2541| 9.81k|{ 2542| 9.81k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2543| 9.81k| (void)yyg; 2544| 9.81k| return malloc(size); 2545| 9.81k|} igraph_dl_yyrealloc: 2548| 213|{ 2549| 213| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2550| 213| (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| 213| return realloc(ptr, size); 2560| 213|} igraph_dl_yyfree: 2563| 12.2k|{ 2564| 12.2k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2565| 12.2k| (void)yyg; 2566| 12.2k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2567| 12.2k|} dl-lexer.c:yy_get_next_buffer: 1551| 12.7k|{ 1552| 12.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1553| 12.7k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 527| 12.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1554| 12.7k| char *source = yyg->yytext_ptr; ------------------ | | 577| 12.7k|#define yytext_ptr yytext_r ------------------ 1555| 12.7k| int number_to_move, i; 1556| 12.7k| int ret_val; 1557| | 1558| 12.7k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 527| 12.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1558:7): [True: 0, False: 12.7k] ------------------ 1559| 12.7k| YY_FATAL_ERROR( ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1560| 12.7k| "fatal flex scanner internal error--end of buffer missed" ); 1561| | 1562| 12.7k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 527| 12.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1562:7): [True: 0, False: 12.7k] ------------------ 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| 12.7k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 577| 12.7k|#define yytext_ptr yytext_r ------------------ 1585| | 1586| 350M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1586:15): [True: 350M, False: 12.7k] ------------------ 1587| 350M| *(dest++) = *(source++); 1588| | 1589| 12.7k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 527| 12.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_EOF_PENDING ) ------------------ | | 510| 12.7k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1589:7): [True: 1.38k, False: 11.3k] ------------------ 1590| | /* don't do the read, it's not guaranteed to return an EOF, 1591| | * just force an EOF 1592| | */ 1593| 1.38k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 527| 1.38k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1594| | 1595| 11.3k| else 1596| 11.3k| { 1597| 11.3k| int num_to_read = 1598| 11.3k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 527| 11.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1599| | 1600| 11.5k| while ( num_to_read <= 0 ) ------------------ | Branch (1600:11): [True: 213, False: 11.3k] ------------------ 1601| 213| { /* Not enough room in the buffer - grow it. */ 1602| | 1603| | /* just a shorter name for the current buffer */ 1604| 213| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 527| 213|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1605| | 1606| 213| int yy_c_buf_p_offset = 1607| 213| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1608| | 1609| 213| if ( b->yy_is_our_buffer ) ------------------ | Branch (1609:9): [True: 213, False: 0] ------------------ 1610| 213| { 1611| 213| int new_size = b->yy_buf_size * 2; 1612| | 1613| 213| if ( new_size <= 0 ) ------------------ | Branch (1613:10): [True: 0, False: 213] ------------------ 1614| 0| b->yy_buf_size += b->yy_buf_size / 8; 1615| 213| else 1616| 213| b->yy_buf_size *= 2; 1617| | 1618| 213| b->yy_ch_buf = (char *) 1619| | /* Include room in for 2 EOB chars. */ 1620| 213| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 242| 213|#define yyrealloc igraph_dl_yyrealloc ------------------ 1621| 213| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1622| 213| } 1623| 0| else 1624| | /* Can't grow it, we don't own it. */ 1625| 0| b->yy_ch_buf = NULL; 1626| | 1627| 213| if ( ! b->yy_ch_buf ) ------------------ | Branch (1627:9): [True: 0, False: 213] ------------------ 1628| 213| YY_FATAL_ERROR( ------------------ | | 892| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1629| 213| "fatal error - scanner input buffer overflow" ); 1630| | 1631| 213| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1632| | 1633| 213| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 527| 213|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1634| 213| number_to_move - 1; 1635| | 1636| 213| } 1637| | 1638| 11.3k| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 1053| 11.3k|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1638:8): [True: 10.7k, False: 663] ------------------ 1639| 10.7k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1053| 10.7k|#define YY_READ_BUF_SIZE 8192 ------------------ 1640| | 1641| | /* Read in more data. */ 1642| 11.3k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 1070| 11.3k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 527| 11.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (1070:7): [True: 0, False: 11.3k] | | ------------------ | | 1071| 11.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) | | | | ------------------ | | | | | | 1078| 0| do { \ | | | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | | | 1080| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (1080:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1081| 0| result = n; \ | | 1082| 0| } \ | | 1083| 11.3k| else \ | | 1084| 11.3k| { \ | | 1085| 11.3k| errno=0; \ | | 1086| 11.3k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 11.3k|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 3.22k|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1086:11): [True: 3.22k, False: 8.15k] | | | Branch (1086:78): [True: 0, False: 3.22k] | | ------------------ | | 1087| 11.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) | | | | ------------------ | | | | | | 1078| 0| do { \ | | | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | | | 1080| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (1080: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| 11.3k| }\ ------------------ 1643| 11.3k| yyg->yy_n_chars, num_to_read ); 1644| | 1645| 11.3k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 527| 11.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1646| 11.3k| } 1647| | 1648| 12.7k| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1648:7): [True: 4.61k, False: 8.15k] ------------------ 1649| 4.61k| { 1650| 4.61k| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 836| 4.61k|#define YY_MORE_ADJ 0 ------------------ | Branch (1650:8): [True: 2.39k, False: 2.21k] ------------------ 1651| 2.39k| { 1652| 2.39k| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 2.39k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1653| 2.39k| yyrestart( yyin , yyscanner); ------------------ | | 98| 2.39k|#define yyrestart igraph_dl_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 2.39k|#define yyin yyg->yyin_r ------------------ 1654| 2.39k| } 1655| | 1656| 2.21k| else 1657| 2.21k| { 1658| 2.21k| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 2.21k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1659| 2.21k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 527| 2.21k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1660| 2.21k| YY_BUFFER_EOF_PENDING; ------------------ | | 510| 2.21k|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1661| 2.21k| } 1662| 4.61k| } 1663| | 1664| 8.15k| else 1665| 8.15k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 8.15k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1666| | 1667| 12.7k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 527| 12.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1667:6): [True: 0, False: 12.7k] ------------------ 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) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080: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| 12.7k| yyg->yy_n_chars += number_to_move; 1679| 12.7k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 12.7k|#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| 12.7k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1680| 12.7k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 12.7k|#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| 12.7k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1681| | 1682| 12.7k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 577| 12.7k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 527| 12.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1683| | 1684| 12.7k| return ret_val; 1685| 12.7k|} dl-lexer.c:yy_get_previous_state: 1690| 10.5k|{ 1691| 10.5k| yy_state_type yy_current_state; 1692| 10.5k| char *yy_cp; 1693| 10.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1694| | 1695| 10.5k| yy_current_state = yyg->yy_start; 1696| | 1697| 351M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 577| 10.5k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 836| 10.5k|#define YY_MORE_ADJ 0 ------------------ | Branch (1697:47): [True: 351M, False: 10.5k] ------------------ 1698| 351M| { 1699| 351M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 46); ------------------ | | 346| 351M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1699:19): [True: 351M, False: 64] ------------------ 1700| 351M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1700:8): [True: 351M, False: 241k] ------------------ 1701| 351M| { 1702| 351M| yyg->yy_last_accepting_state = yy_current_state; 1703| 351M| yyg->yy_last_accepting_cpos = yy_cp; 1704| 351M| } 1705| 467M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1705:11): [True: 116M, False: 351M] ------------------ 1706| 116M| { 1707| 116M| yy_current_state = (int) yy_def[yy_current_state]; 1708| 116M| if ( yy_current_state >= 129 ) ------------------ | Branch (1708:9): [True: 116M, False: 90.0k] ------------------ 1709| 116M| yy_c = yy_meta[yy_c]; 1710| 116M| } 1711| 351M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1712| 351M| } 1713| | 1714| 10.5k| return yy_current_state; 1715| 10.5k|} dl-lexer.c:yy_try_NUL_trans: 1723| 200|{ 1724| 200| int yy_is_jam; 1725| 200| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ 1726| 200| char *yy_cp = yyg->yy_c_buf_p; 1727| | 1728| 200| YY_CHAR yy_c = 46; 1729| 200| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1729:7): [True: 120, False: 80] ------------------ 1730| 120| { 1731| 120| yyg->yy_last_accepting_state = yy_current_state; 1732| 120| yyg->yy_last_accepting_cpos = yy_cp; 1733| 120| } 1734| 415| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1734:10): [True: 215, False: 200] ------------------ 1735| 215| { 1736| 215| yy_current_state = (int) yy_def[yy_current_state]; 1737| 215| if ( yy_current_state >= 129 ) ------------------ | Branch (1737:8): [True: 73, False: 142] ------------------ 1738| 73| yy_c = yy_meta[yy_c]; 1739| 215| } 1740| 200| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1741| 200| yy_is_jam = (yy_current_state == 128); 1742| | 1743| 200| (void)yyg; 1744| 200| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (1744:9): [True: 133, False: 67] ------------------ 1745| 200|} dl-lexer.c:igraph_dl_yy_load_buffer_state: 1889| 7.24k|{ 1890| 7.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1891| 7.24k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 7.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1892| 7.24k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 577| 7.24k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 527| 7.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1893| 7.24k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 7.24k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 527| 7.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1894| 7.24k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1895| 7.24k|} dl-lexer.c:igraph_dl_yy_init_buffer: 1953| 4.85k|{ 1954| 4.85k| int oerrno = errno; 1955| 4.85k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1956| | 1957| 4.85k| yy_flush_buffer( b , yyscanner); ------------------ | | 56| 4.85k|#define yy_flush_buffer igraph_dl_yy_flush_buffer ------------------ 1958| | 1959| 4.85k| b->yy_input_file = file; 1960| 4.85k| 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.85k| if (b != YY_CURRENT_BUFFER){ ------------------ | | 521| 4.85k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.85k, False: 0] | | ------------------ | | 522| 4.85k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.85k| : NULL) ------------------ | Branch (1966:9): [True: 2.45k, False: 2.39k] ------------------ 1967| 2.45k| b->yy_bs_lineno = 1; 1968| 2.45k| b->yy_bs_column = 0; 1969| 2.45k| } 1970| | 1971| 4.85k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (1971:32): [True: 4.85k, False: 0] ------------------ 1972| | 1973| 4.85k| errno = oerrno; 1974| 4.85k|} dl-lexer.c:igraph_dl_yyensure_buffer_stack: 2062| 2.45k|{ 2063| 2.45k| yy_size_t num_to_alloc; 2064| 2.45k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2065| | 2066| 2.45k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2066:6): [True: 2.45k, 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.45k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2073| 2.45k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 2.45k|#define yyalloc igraph_dl_yyalloc ------------------ 2074| 2.45k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2075| 2.45k| , yyscanner); 2076| 2.45k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2076:8): [True: 0, False: 2.45k] ------------------ 2077| 2.45k| 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) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2078| | 2079| 2.45k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2080| | 2081| 2.45k| yyg->yy_buffer_stack_max = num_to_alloc; 2082| 2.45k| yyg->yy_buffer_stack_top = 0; 2083| 2.45k| return; 2084| 2.45k| } 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) | | ------------------ | | | | 1078| 0| do { \ | | | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 1080| 0| } while (0) | | | | ------------------ | | | | | Branch (1080: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.90k|{ 2452| 4.90k| 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.90k| yyg->yy_buffer_stack = NULL; 2458| 4.90k| yyg->yy_buffer_stack_top = 0; 2459| 4.90k| yyg->yy_buffer_stack_max = 0; 2460| 4.90k| yyg->yy_c_buf_p = NULL; 2461| 4.90k| yyg->yy_init = 0; 2462| 4.90k| yyg->yy_start = 0; 2463| | 2464| 4.90k| yyg->yy_start_stack_ptr = 0; 2465| 4.90k| yyg->yy_start_stack_depth = 0; 2466| 4.90k| 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.90k| yyin = NULL; ------------------ | | 356| 4.90k|#define yyin yyg->yyin_r ------------------ 2474| 4.90k| yyout = NULL; ------------------ | | 357| 4.90k|#define yyout yyg->yyout_r ------------------ 2475| 4.90k|#endif 2476| | 2477| | /* For future reference: Set errno on error, since we are called by 2478| | * yylex_init() 2479| | */ 2480| 4.90k| return 0; 2481| 4.90k|} igraph_dl_yyparse: 1291| 2.45k|{ 1292| |/* The lookahead symbol. */ 1293| 2.45k|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.45k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 370| 2.45k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1300| 2.45k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 370| 2.45k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1301| | 1302| |/* Location data for the lookahead symbol. */ 1303| 2.45k|static YYLTYPE yyloc_default 1304| 2.45k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1305| 2.45k| = { 1, 1, 1, 1 } 1306| 2.45k|# endif 1307| 2.45k|; 1308| 2.45k|YYLTYPE yylloc = yyloc_default; 1309| | 1310| | /* Number of syntax errors so far. */ 1311| 2.45k| int yynerrs; 1312| | 1313| 2.45k| yy_state_fast_t yystate; 1314| | /* Number of tokens to shift before error messages enabled. */ 1315| 2.45k| 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.45k| yy_state_t yyssa[YYINITDEPTH]; 1327| 2.45k| yy_state_t *yyss; 1328| 2.45k| yy_state_t *yyssp; 1329| | 1330| | /* The semantic value stack. */ 1331| 2.45k| YYSTYPE yyvsa[YYINITDEPTH]; 1332| 2.45k| YYSTYPE *yyvs; 1333| 2.45k| YYSTYPE *yyvsp; 1334| | 1335| | /* The location stack. */ 1336| 2.45k| YYLTYPE yylsa[YYINITDEPTH]; 1337| 2.45k| YYLTYPE *yyls; 1338| 2.45k| YYLTYPE *yylsp; 1339| | 1340| | /* The locations where the error started and ended. */ 1341| 2.45k| YYLTYPE yyerror_range[3]; 1342| | 1343| 2.45k| YYPTRDIFF_T yystacksize; ------------------ | | 285| 2.45k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1344| | 1345| 2.45k| int yyn; 1346| 2.45k| int yyresult; 1347| | /* Lookahead token as an internal (translated) token number. */ 1348| 2.45k| int yytoken = 0; 1349| | /* The variables used to return semantic value and location from the 1350| | action routines. */ 1351| 2.45k| YYSTYPE yyval; 1352| 2.45k| YYLTYPE yyloc; 1353| | 1354| 2.45k|#if YYERROR_VERBOSE 1355| | /* Buffer for error messages, and its allocated size. */ 1356| 2.45k| char yymsgbuf[128]; 1357| 2.45k| char *yymsg = yymsgbuf; 1358| 2.45k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 285| 2.45k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1359| 2.45k|#endif 1360| | 1361| 2.45k|#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.45k| int yylen = 0; 1366| | 1367| 2.45k| yyssp = yyss = yyssa; 1368| 2.45k| yyvsp = yyvs = yyvsa; 1369| 2.45k| yylsp = yyls = yylsa; 1370| 2.45k| yystacksize = YYINITDEPTH; ------------------ | | 1016| 2.45k|# define YYINITDEPTH 200 ------------------ 1371| | 1372| 2.45k| YYDPRINTF ((stderr, "Starting parse\n")); 1373| | 1374| 2.45k| yystate = 0; 1375| 2.45k| yyerrstatus = 0; 1376| 2.45k| yynerrs = 0; ------------------ | | 71| 2.45k|#define yynerrs igraph_dl_yynerrs ------------------ 1377| 2.45k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 780| 2.45k|#define YYEMPTY (-2) ------------------ 1378| 2.45k| yylsp[0] = yylloc; 1379| 2.45k| goto yysetstate; 1380| | 1381| | 1382| |/*------------------------------------------------------------. 1383| || yynewstate -- push a new state, which is found in yystate. | 1384| |`------------------------------------------------------------*/ 1385| 27.7M|yynewstate: 1386| | /* In all cases, when you get here, the value and location stacks 1387| | have just been pushed. So pushing a state here evens the stacks. */ 1388| 27.7M| yyssp++; 1389| | 1390| | 1391| |/*--------------------------------------------------------------------. 1392| || yysetstate -- set current state (the top of the stack) to yystate. | 1393| |`--------------------------------------------------------------------*/ 1394| 27.7M|yysetstate: 1395| 27.7M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1396| 27.7M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 393| 27.7M|#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| 27.7M| YY_IGNORE_USELESS_CAST_BEGIN 1398| 27.7M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 126| 27.7M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1399| 27.7M| YY_IGNORE_USELESS_CAST_END 1400| | 1401| 27.7M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1401:7): [True: 0, False: 27.7M] ------------------ 1402| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1403| | goto yyexhaustedlab; 1404| |#else 1405| 0| { 1406| | /* Get the current used size of the three stacks, in elements. */ 1407| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 285| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1408| | 1409| |# if defined yyoverflow 1410| | { 1411| | /* Give user a chance to reallocate the stack. Use copies of 1412| | these so that the &'s don't force the real ones into 1413| | memory. */ 1414| | yy_state_t *yyss1 = yyss; 1415| | YYSTYPE *yyvs1 = yyvs; 1416| | YYLTYPE *yyls1 = yyls; 1417| | 1418| | /* Each stack pointer address is followed by the size of the 1419| | data in use in that stack, in bytes. This used to be a 1420| | conditional around just the two extra args, but that might 1421| | be undefined if yyoverflow is a macro. */ 1422| | yyoverflow (YY_("memory exhausted"), 1423| | &yyss1, yysize * YYSIZEOF (*yyssp), 1424| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1425| | &yyls1, yysize * YYSIZEOF (*yylsp), 1426| | &yystacksize); 1427| | yyss = yyss1; 1428| | yyvs = yyvs1; 1429| | yyls = yyls1; 1430| | } 1431| |# else /* defined YYSTACK_RELOCATE */ 1432| | /* Extend the stack our own way. */ 1433| 0| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1027| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1433:11): [True: 0, False: 0] ------------------ 1434| 0| goto yyexhaustedlab; 1435| 0| yystacksize *= 2; 1436| 0| if (YYMAXDEPTH < yystacksize) ------------------ | | 1027| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1436:11): [True: 0, False: 0] ------------------ 1437| 0| yystacksize = YYMAXDEPTH; ------------------ | | 1027| 0|# define YYMAXDEPTH 10000 ------------------ 1438| | 1439| 0| { 1440| 0| yy_state_t *yyss1 = yyss; 1441| 0| union yyalloc *yyptr = 1442| 0| YY_CAST (union yyalloc *, ------------------ | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1443| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1444| 0| if (! yyptr) ------------------ | Branch (1444:13): [True: 0, False: 0] ------------------ 1445| 0| goto yyexhaustedlab; 1446| 0| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 494| 0| do \ | | 495| 0| { \ | | 496| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 285| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 497| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 512| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 498| 0| Stack = &yyptr->Stack_alloc; \ | | 499| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 477| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 500| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 501| 0| } \ | | 502| 0| while (0) | | ------------------ | | | Branch (502:12): [Folded - 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| 27.7M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1468| | 1469| 27.7M| if (yystate == YYFINAL) ------------------ | | 527| 27.7M|#define YYFINAL 4 ------------------ | Branch (1469:7): [True: 892, False: 27.7M] ------------------ 1470| 892| YYACCEPT; ------------------ | | 783| 892|#define YYACCEPT goto yyacceptlab ------------------ 1471| | 1472| 27.7M| goto yybackup; 1473| | 1474| | 1475| |/*-----------. 1476| || yybackup. | 1477| |`-----------*/ 1478| 27.7M|yybackup: 1479| | /* Do appropriate processing given the current state. Read a 1480| | lookahead token if we need one and don't already have one. */ 1481| | 1482| | /* First try to decide what to do without reference to lookahead token. */ 1483| 27.7M| yyn = yypact[yystate]; 1484| 27.7M| if (yypact_value_is_default (yyn)) ------------------ | | 632| 27.7M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 27.7M|#define YYPACT_NINF (-114) | | ------------------ | | | Branch (632:3): [True: 15.5M, False: 12.2M] | | ------------------ ------------------ 1485| 15.5M| goto yydefault; 1486| | 1487| | /* Not known => get a lookahead token if don't already have one. */ 1488| | 1489| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1490| 12.2M| if (yychar == YYEMPTY) ------------------ | | 780| 12.2M|#define YYEMPTY (-2) ------------------ | Branch (1490:7): [True: 11.0M, False: 1.13M] ------------------ 1491| 11.0M| { 1492| 11.0M| YYDPRINTF ((stderr, "Reading a token: ")); 1493| 11.0M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 68| 11.0M|#define yylex igraph_dl_yylex ------------------ yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 116| 11.0M|#define scanner context->scanner ------------------ 1494| 11.0M| } 1495| | 1496| 12.2M| if (yychar <= YYEOF) ------------------ | | 781| 12.2M|#define YYEOF 0 ------------------ | Branch (1496:7): [True: 1.07k, False: 12.2M] ------------------ 1497| 1.07k| { 1498| 1.07k| yychar = yytoken = YYEOF; ------------------ | | 781| 1.07k|#define YYEOF 0 ------------------ 1499| 1.07k| YYDPRINTF ((stderr, "Now at end of input.\n")); 1500| 1.07k| } 1501| 12.2M| else 1502| 12.2M| { 1503| 12.2M| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 12.2M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 12.2M|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 12.2M, False: 0] | | | Branch (547:18): [True: 12.2M, False: 0] | | ------------------ ------------------ 1504| 12.2M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1505| 12.2M| } 1506| | 1507| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1508| | detect an error, take that action. */ 1509| 12.2M| yyn += yytoken; 1510| 12.2M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 529| 12.2M|#define YYLAST 118 ------------------ | Branch (1510:7): [True: 0, False: 12.2M] | Branch (1510:18): [True: 0, False: 12.2M] | Branch (1510:34): [True: 1.12M, False: 11.0M] ------------------ 1511| 1.12M| goto yydefault; 1512| 11.0M| yyn = yytable[yyn]; 1513| 11.0M| if (yyn <= 0) ------------------ | Branch (1513:7): [True: 13.8k, False: 11.0M] ------------------ 1514| 13.8k| { 1515| 13.8k| if (yytable_value_is_error (yyn)) ------------------ | | 637| 13.8k| 0 | | ------------------ | | | Branch (637:3): [Folded - Ignored] | | ------------------ ------------------ 1516| 0| goto yyerrlab; 1517| 13.8k| yyn = -yyn; 1518| 13.8k| goto yyreduce; 1519| 13.8k| } 1520| | 1521| | /* Count tokens shifted since error; after three, turn off error 1522| | status. */ 1523| 11.0M| if (yyerrstatus) ------------------ | Branch (1523:7): [True: 0, False: 11.0M] ------------------ 1524| 0| yyerrstatus--; 1525| | 1526| | /* Shift the lookahead token. */ 1527| 11.0M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1528| 11.0M| yystate = yyn; 1529| 11.0M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1530| 11.0M| *++yyvsp = yylval; 1531| 11.0M| YY_IGNORE_MAYBE_UNINITIALIZED_END 1532| 11.0M| *++yylsp = yylloc; 1533| | 1534| | /* Discard the shifted token. */ 1535| 11.0M| yychar = YYEMPTY; ------------------ | | 780| 11.0M|#define YYEMPTY (-2) ------------------ 1536| 11.0M| goto yynewstate; 1537| | 1538| | 1539| |/*-----------------------------------------------------------. 1540| || yydefault -- do the default action for the current state. | 1541| |`-----------------------------------------------------------*/ 1542| 16.7M|yydefault: 1543| 16.7M| yyn = yydefact[yystate]; 1544| 16.7M| if (yyn == 0) ------------------ | Branch (1544:7): [True: 843, False: 16.7M] ------------------ 1545| 843| goto yyerrlab; 1546| 16.7M| goto yyreduce; 1547| | 1548| | 1549| |/*-----------------------------. 1550| || yyreduce -- do a reduction. | 1551| |`-----------------------------*/ 1552| 16.7M|yyreduce: 1553| | /* yyn is the number of a rule to reduce with. */ 1554| 16.7M| yylen = yyr2[yyn]; 1555| | 1556| | /* If YYLEN is nonzero, implement the default value of the action: 1557| | '$$ = $1'. 1558| | 1559| | Otherwise, the following line sets YYVAL to garbage. 1560| | This behavior is undocumented and Bison 1561| | users should not rely upon it. Assigning to YYVAL 1562| | unconditionally makes the parser a bit smaller, and it avoids a 1563| | GCC warning that YYVAL may be used uninitialized. */ 1564| 16.7M| yyval = yyvsp[1-yylen]; 1565| | 1566| | /* Default location. */ 1567| 16.7M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 818| 16.7M| do \ | | 819| 16.7M| if (N) \ | | ------------------ | | | Branch (819:11): [True: 15.5M, False: 1.16M] | | ------------------ | | 820| 16.7M| { \ | | 821| 15.5M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 836| 15.5M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 822| 15.5M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 836| 15.5M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 823| 15.5M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 836| 15.5M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 824| 15.5M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 836| 15.5M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 825| 15.5M| } \ | | 826| 16.7M| else \ | | 827| 16.7M| { \ | | 828| 1.16M| (Current).first_line = (Current).last_line = \ | | 829| 1.16M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 836| 1.16M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 830| 1.16M| (Current).first_column = (Current).last_column = \ | | 831| 1.16M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 836| 1.16M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 832| 1.16M| } \ | | 833| 16.7M| while (0) | | ------------------ | | | Branch (833:12): [Folded - Ignored] | | ------------------ ------------------ 1568| 16.7M| yyerror_range[1] = yyloc; 1569| 16.7M| YY_REDUCE_PRINT (yyn); 1570| 16.7M| switch (yyn) 1571| 16.7M| { 1572| 985| case 2: ------------------ | Branch (1572:3): [True: 985, False: 16.7M] ------------------ 1573| 985|#line 104 "/src/igraph/src/io/dl-parser.y" 1574| 985| { 1575| 985| context->n=(yyvsp[-4].integer); 1576| 985| if (context->n < 0) { ------------------ | Branch (1576:7): [True: 0, False: 985] ------------------ 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| 985| if (context->n > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 985|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (1579:7): [True: 47, False: 938] ------------------ 1580| 47| IGRAPH_YY_ERRORF("Vertex count too large in DL file (%" IGRAPH_PRId ").", IGRAPH_EINVAL, context->n); ------------------ | | 24| 47| do { \ | | 25| 47| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 47| error_code, __VA_ARGS__) ; \ | | 27| 47| context->igraph_errno = error_code; \ | | 28| 47| YYABORT; \ | | ------------------ | | | | 784| 47|#define YYABORT goto yyabortlab | | ------------------ | | 29| 47| } while (0) | | ------------------ | | | Branch (29:14): [Folded - Ignored] | | ------------------ ------------------ 1581| 47| } 1582| 985|} 1583| 938|#line 1584 "/src/igraph/build/src/io/parsers/dl-parser.c" 1584| 938| break; 1585| | 1586| 938| case 7: ------------------ | Branch (1586:3): [True: 482, False: 16.7M] ------------------ 1587| 482|#line 118 "/src/igraph/src/io/dl-parser.y" 1588| 482| { context->type=IGRAPH_DL_MATRIX; } 1589| 482|#line 1590 "/src/igraph/build/src/io/parsers/dl-parser.c" 1590| 482| break; 1591| | 1592| 395| case 8: ------------------ | Branch (1592:3): [True: 395, False: 16.7M] ------------------ 1593| 395|#line 119 "/src/igraph/src/io/dl-parser.y" 1594| 395| { context->type=IGRAPH_DL_EDGELIST1; } 1595| 395|#line 1596 "/src/igraph/build/src/io/parsers/dl-parser.c" 1596| 395| break; 1597| | 1598| 108| case 9: ------------------ | Branch (1598:3): [True: 108, False: 16.7M] ------------------ 1599| 108|#line 120 "/src/igraph/src/io/dl-parser.y" 1600| 108| { context->type=IGRAPH_DL_NODELIST1; } 1601| 108|#line 1602 "/src/igraph/build/src/io/parsers/dl-parser.c" 1602| 108| break; 1603| | 1604| 0| case 10: ------------------ | Branch (1604:3): [True: 0, False: 16.7M] ------------------ 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| 482| case 11: ------------------ | Branch (1610:3): [True: 482, False: 16.7M] ------------------ 1611| 482|#line 123 "/src/igraph/src/io/dl-parser.y" 1612| 482| {} 1613| 482|#line 1614 "/src/igraph/build/src/io/parsers/dl-parser.c" 1614| 482| break; 1615| | 1616| 369| case 14: ------------------ | Branch (1616:3): [True: 369, False: 16.7M] ------------------ 1617| 369|#line 127 "/src/igraph/src/io/dl-parser.y" 1618| 369| { } 1619| 369|#line 1620 "/src/igraph/build/src/io/parsers/dl-parser.c" 1620| 369| break; 1621| | 1622| 100| case 15: ------------------ | Branch (1622:3): [True: 100, False: 16.7M] ------------------ 1623| 100|#line 128 "/src/igraph/src/io/dl-parser.y" 1624| 100| { } 1625| 100|#line 1626 "/src/igraph/build/src/io/parsers/dl-parser.c" 1626| 100| break; 1627| | 1628| 13| case 16: ------------------ | Branch (1628:3): [True: 13, False: 16.7M] ------------------ 1629| 13|#line 129 "/src/igraph/src/io/dl-parser.y" 1630| 13| { } 1631| 13|#line 1632 "/src/igraph/build/src/io/parsers/dl-parser.c" 1632| 13| break; 1633| | 1634| 337| case 17: ------------------ | Branch (1634:3): [True: 337, False: 16.7M] ------------------ 1635| 337|#line 132 "/src/igraph/src/io/dl-parser.y" 1636| 337| {} 1637| 337|#line 1638 "/src/igraph/build/src/io/parsers/dl-parser.c" 1638| 337| break; 1639| | 1640| 1.81M| case 18: ------------------ | Branch (1640:3): [True: 1.81M, False: 14.9M] ------------------ 1641| 1.81M|#line 133 "/src/igraph/src/io/dl-parser.y" 1642| 1.81M| { 1643| 1.81M| IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.81M| do { \ | | 11| 1.81M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.81M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 1.81M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.81M] | | | | ------------------ | | ------------------ | | 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.81M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1644| 1.81M| igraph_dl_yyget_leng(scanner), 1645| 1.81M| context)); } 1646| 1.81M|#line 1647 "/src/igraph/build/src/io/parsers/dl-parser.c" 1647| 1.81M| break; 1648| | 1649| 1.81M| case 19: ------------------ | Branch (1649:3): [True: 499, False: 16.7M] ------------------ 1650| 499|#line 139 "/src/igraph/src/io/dl-parser.y" 1651| 499| {} 1652| 499|#line 1653 "/src/igraph/build/src/io/parsers/dl-parser.c" 1653| 499| break; 1654| | 1655| 13.7k| case 20: ------------------ | Branch (1655:3): [True: 13.7k, False: 16.7M] ------------------ 1656| 13.7k|#line 139 "/src/igraph/src/io/dl-parser.y" 1657| 13.7k| { 1658| 13.7k| context->from += 1; 1659| 13.7k| context->to = 0; 1660| 13.7k| } 1661| 13.7k|#line 1662 "/src/igraph/build/src/io/parsers/dl-parser.c" 1662| 13.7k| break; 1663| | 1664| 2.35M| case 22: ------------------ | Branch (1664:3): [True: 2.35M, False: 14.3M] ------------------ 1665| 2.35M|#line 144 "/src/igraph/src/io/dl-parser.y" 1666| 2.35M| { } 1667| 2.35M|#line 1668 "/src/igraph/build/src/io/parsers/dl-parser.c" 1668| 2.35M| break; 1669| | 1670| 2.35M| case 23: ------------------ | Branch (1670:3): [True: 2.35M, False: 14.3M] ------------------ 1671| 2.35M|#line 146 "/src/igraph/src/io/dl-parser.y" 1672| 2.35M| { 1673| | /* TODO: What if the digit is neither 0 or 1? Are multigraphs allowed? */ 1674| 2.35M| char c = igraph_dl_yyget_text(scanner)[0]; ------------------ | | 116| 2.35M|#define scanner context->scanner ------------------ 1675| 2.35M| if (c == '1') { ------------------ | Branch (1675:7): [True: 2.34M, False: 4.86k] ------------------ 1676| 2.34M| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 2.34M| do { \ | | 11| 2.34M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.34M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 2.34M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.34M] | | | | ------------------ | | ------------------ | | 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.34M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1677| 2.34M| context->from)); 1678| 2.34M| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 2.34M| do { \ | | 11| 2.34M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.34M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 2.34M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.34M] | | | | ------------------ | | ------------------ | | 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.34M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1679| 2.34M| context->to)); 1680| 2.34M| } else if (c != '0') { ------------------ | Branch (1680:14): [True: 5, False: 4.86k] ------------------ 1681| 5| IGRAPH_YY_ERRORF("Unexpected digit '%c' in adjacency matrix in DL file.", ------------------ | | 24| 5| do { \ | | 25| 5| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 5| error_code, __VA_ARGS__) ; \ | | 27| 5| context->igraph_errno = error_code; \ | | 28| 5| YYABORT; \ | | ------------------ | | | | 784| 5|#define YYABORT goto yyabortlab | | ------------------ | | 29| 5| } while (0) | | ------------------ | | | Branch (29:14): [Folded - Ignored] | | ------------------ ------------------ 1682| 5| IGRAPH_EINVAL, c); 1683| 5| } 1684| 2.35M| context->to += 1; 1685| 2.35M|} 1686| 0|#line 1687 "/src/igraph/build/src/io/parsers/dl-parser.c" 1687| 0| break; 1688| | 1689| 13| case 24: ------------------ | Branch (1689:3): [True: 13, False: 16.7M] ------------------ 1690| 13|#line 161 "/src/igraph/src/io/dl-parser.y" 1691| 13| {} 1692| 13|#line 1693 "/src/igraph/build/src/io/parsers/dl-parser.c" 1693| 13| break; 1694| | 1695| 13| case 25: ------------------ | Branch (1695:3): [True: 13, False: 16.7M] ------------------ 1696| 13|#line 163 "/src/igraph/src/io/dl-parser.y" 1697| 13| {} 1698| 13|#line 1699 "/src/igraph/build/src/io/parsers/dl-parser.c" 1699| 13| break; 1700| | 1701| 1.17k| case 28: ------------------ | Branch (1701:3): [True: 1.17k, False: 16.7M] ------------------ 1702| 1.17k|#line 167 "/src/igraph/src/io/dl-parser.y" 1703| 1.17k| { IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.17k| do { \ | | 11| 1.17k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 1.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.17k] | | | | ------------------ | | ------------------ | | 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.17k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1704| 1.17k| igraph_dl_yyget_leng(scanner), 1705| 1.17k| context)); } 1706| 1.17k|#line 1707 "/src/igraph/build/src/io/parsers/dl-parser.c" 1707| 1.17k| break; 1708| | 1709| 1.17k| case 29: ------------------ | Branch (1709:3): [True: 13, False: 16.7M] ------------------ 1710| 13|#line 171 "/src/igraph/src/io/dl-parser.y" 1711| 13| { 1712| 13| context->from += 1; 1713| 13| context->to = 0; 1714| 13| } 1715| 13|#line 1716 "/src/igraph/build/src/io/parsers/dl-parser.c" 1716| 13| break; 1717| | 1718| 223| case 30: ------------------ | Branch (1718:3): [True: 223, False: 16.7M] ------------------ 1719| 223|#line 175 "/src/igraph/src/io/dl-parser.y" 1720| 223| { 1721| 223| context->from += 1; 1722| 223| context->to = 0; 1723| 223| } 1724| 223|#line 1725 "/src/igraph/build/src/io/parsers/dl-parser.c" 1725| 223| break; 1726| | 1727| 236| case 31: ------------------ | Branch (1727:3): [True: 236, False: 16.7M] ------------------ 1728| 236|#line 180 "/src/igraph/src/io/dl-parser.y" 1729| 236| { } 1730| 236|#line 1731 "/src/igraph/build/src/io/parsers/dl-parser.c" 1731| 236| break; 1732| | 1733| 395| case 32: ------------------ | Branch (1733:3): [True: 395, False: 16.7M] ------------------ 1734| 395|#line 184 "/src/igraph/src/io/dl-parser.y" 1735| 395| {} 1736| 395|#line 1737 "/src/igraph/build/src/io/parsers/dl-parser.c" 1737| 395| break; 1738| | 1739| 363| case 33: ------------------ | Branch (1739:3): [True: 363, False: 16.7M] ------------------ 1740| 363|#line 186 "/src/igraph/src/io/dl-parser.y" 1741| 363| {} 1742| 363|#line 1743 "/src/igraph/build/src/io/parsers/dl-parser.c" 1743| 363| break; 1744| | 1745| 6| case 34: ------------------ | Branch (1745:3): [True: 6, False: 16.7M] ------------------ 1746| 6|#line 187 "/src/igraph/src/io/dl-parser.y" 1747| 6| {} 1748| 6|#line 1749 "/src/igraph/build/src/io/parsers/dl-parser.c" 1749| 6| break; 1750| | 1751| 26| case 35: ------------------ | Branch (1751:3): [True: 26, False: 16.7M] ------------------ 1752| 26|#line 188 "/src/igraph/src/io/dl-parser.y" 1753| 26| {} 1754| 26|#line 1755 "/src/igraph/build/src/io/parsers/dl-parser.c" 1755| 26| break; 1756| | 1757| 0| case 36: ------------------ | Branch (1757:3): [True: 0, False: 16.7M] ------------------ 1758| 0|#line 189 "/src/igraph/src/io/dl-parser.y" 1759| 0| {} 1760| 0|#line 1761 "/src/igraph/build/src/io/parsers/dl-parser.c" 1761| 0| break; 1762| | 1763| 0| case 37: ------------------ | Branch (1763:3): [True: 0, False: 16.7M] ------------------ 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| 955| case 38: ------------------ | Branch (1769:3): [True: 955, False: 16.7M] ------------------ 1770| 955|#line 193 "/src/igraph/src/io/dl-parser.y" 1771| 955| {} 1772| 955|#line 1773 "/src/igraph/build/src/io/parsers/dl-parser.c" 1773| 955| break; 1774| | 1775| 1.98M| case 39: ------------------ | Branch (1775:3): [True: 1.98M, False: 14.7M] ------------------ 1776| 1.98M|#line 194 "/src/igraph/src/io/dl-parser.y" 1777| 1.98M| {} 1778| 1.98M|#line 1779 "/src/igraph/build/src/io/parsers/dl-parser.c" 1779| 1.98M| break; 1780| | 1781| 60.5k| case 40: ------------------ | Branch (1781:3): [True: 60.5k, False: 16.6M] ------------------ 1782| 60.5k|#line 197 "/src/igraph/src/io/dl-parser.y" 1783| 60.5k| { 1784| 60.5k| igraph_integer_t from = (yyvsp[-3].integer), to = (yyvsp[-2].integer); 1785| 60.5k| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(from)); ------------------ | | 10| 60.5k| do { \ | | 11| 60.5k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 60.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 60.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 123, False: 60.4k] | | | | ------------------ | | ------------------ | | 13| 123| context->igraph_errno = igraph_i_ret; \ | | 14| 123| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 123|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 123| YYABORT; \ | | ------------------ | | | | 784| 123|#define YYABORT goto yyabortlab | | ------------------ | | 16| 123| } \ | | 17| 60.5k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1786| 60.4k| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 60.4k| do { \ | | 11| 60.4k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 60.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 60.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 125, False: 60.3k] | | | | ------------------ | | ------------------ | | 13| 125| context->igraph_errno = igraph_i_ret; \ | | 14| 125| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 125|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 125| YYABORT; \ | | ------------------ | | | | 784| 125|#define YYABORT goto yyabortlab | | ------------------ | | 16| 125| } \ | | 17| 60.4k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1787| 60.3k| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w(from-1, to-1, (yyvsp[-1].real), context)); } ------------------ | | 10| 60.3k| do { \ | | 11| 60.3k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 60.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 60.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 60.3k] | | | | ------------------ | | ------------------ | | 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| 60.3k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1788| 60.3k|#line 1789 "/src/igraph/build/src/io/parsers/dl-parser.c" 1789| 60.3k| break; 1790| | 1791| 1.92M| case 41: ------------------ | Branch (1791:3): [True: 1.92M, False: 14.7M] ------------------ 1792| 1.92M|#line 202 "/src/igraph/src/io/dl-parser.y" 1793| 1.92M| { 1794| 1.92M| igraph_integer_t from = (yyvsp[-2].integer), to = (yyvsp[-1].integer); 1795| 1.92M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(from)); ------------------ | | 10| 1.92M| do { \ | | 11| 1.92M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.92M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 1.92M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 123, False: 1.92M] | | | | ------------------ | | ------------------ | | 13| 123| context->igraph_errno = igraph_i_ret; \ | | 14| 123| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 123|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 123| YYABORT; \ | | ------------------ | | | | 784| 123|#define YYABORT goto yyabortlab | | ------------------ | | 16| 123| } \ | | 17| 1.92M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1796| 1.92M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 1.92M| do { \ | | 11| 1.92M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.92M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 1.92M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 126, False: 1.92M] | | | | ------------------ | | ------------------ | | 13| 126| context->igraph_errno = igraph_i_ret; \ | | 14| 126| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 126|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 126| YYABORT; \ | | ------------------ | | | | 784| 126|#define YYABORT goto yyabortlab | | ------------------ | | 16| 126| } \ | | 17| 1.92M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1797| 1.92M| IGRAPH_YY_CHECK(igraph_i_dl_add_edge(from-1, to-1, context)); ------------------ | | 10| 1.92M| do { \ | | 11| 1.92M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.92M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 1.92M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.92M] | | | | ------------------ | | ------------------ | | 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.92M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1798| 1.92M|} 1799| 1.92M|#line 1800 "/src/igraph/build/src/io/parsers/dl-parser.c" 1800| 1.92M| break; 1801| | 1802| 3.97M| case 42: ------------------ | Branch (1802:3): [True: 3.97M, False: 12.7M] ------------------ 1803| 3.97M|#line 209 "/src/igraph/src/io/dl-parser.y" 1804| 3.97M| { 1805| 3.97M| igraph_integer_t val; 1806| 3.97M| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 3.97M| do { \ | | 11| 3.97M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.97M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 3.97M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 26, False: 3.97M] | | | | ------------------ | | ------------------ | | 13| 26| context->igraph_errno = igraph_i_ret; \ | | 14| 26| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 26|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 26| YYABORT; \ | | ------------------ | | | | 784| 26|#define YYABORT goto yyabortlab | | ------------------ | | 16| 26| } \ | | 17| 3.97M| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1807| 3.97M| igraph_dl_yyget_leng(scanner), 1808| 3.97M| &val)); 1809| 3.97M| (yyval.integer)=val; 1810| 3.97M|} 1811| 0|#line 1812 "/src/igraph/build/src/io/parsers/dl-parser.c" 1812| 0| break; 1813| | 1814| 61| case 43: ------------------ | Branch (1814:3): [True: 61, False: 16.7M] ------------------ 1815| 61|#line 217 "/src/igraph/src/io/dl-parser.y" 1816| 61| {} 1817| 61|#line 1818 "/src/igraph/build/src/io/parsers/dl-parser.c" 1818| 61| break; 1819| | 1820| 845| case 44: ------------------ | Branch (1820:3): [True: 845, False: 16.7M] ------------------ 1821| 845|#line 218 "/src/igraph/src/io/dl-parser.y" 1822| 845| {} 1823| 845|#line 1824 "/src/igraph/build/src/io/parsers/dl-parser.c" 1824| 845| break; 1825| | 1826| 197| case 45: ------------------ | Branch (1826:3): [True: 197, False: 16.7M] ------------------ 1827| 197|#line 221 "/src/igraph/src/io/dl-parser.y" 1828| 197| { 1829| 197| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w((yyvsp[-3].integer), (yyvsp[-2].integer), (yyvsp[-1].real), context)); } ------------------ | | 10| 197| do { \ | | 11| 197| igraph_error_t igraph_i_ret = (expr); \ | | 12| 197| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 197| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 197] | | | | ------------------ | | ------------------ | | 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| 197| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1830| 197|#line 1831 "/src/igraph/build/src/io/parsers/dl-parser.c" 1831| 197| break; 1832| | 1833| 648| case 46: ------------------ | Branch (1833:3): [True: 648, False: 16.7M] ------------------ 1834| 648|#line 223 "/src/igraph/src/io/dl-parser.y" 1835| 648| { 1836| 648| IGRAPH_YY_CHECK(igraph_i_dl_add_edge((yyvsp[-2].integer), (yyvsp[-1].integer), context)); ------------------ | | 10| 648| do { \ | | 11| 648| igraph_error_t igraph_i_ret = (expr); \ | | 12| 648| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 648| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 648] | | | | ------------------ | | ------------------ | | 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| 648| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1837| 648| } 1838| 648|#line 1839 "/src/igraph/build/src/io/parsers/dl-parser.c" 1839| 648| break; 1840| | 1841| 60.8k| case 47: ------------------ | Branch (1841:3): [True: 60.8k, False: 16.6M] ------------------ 1842| 60.8k|#line 227 "/src/igraph/src/io/dl-parser.y" 1843| 60.8k| { 1844| 60.8k| igraph_real_t val; 1845| 60.8k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_dl_yyget_text(scanner), ------------------ | | 10| 60.8k| do { \ | | 11| 60.8k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 60.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 60.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 25, False: 60.8k] | | | | ------------------ | | ------------------ | | 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| 60.8k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1846| 60.8k| igraph_dl_yyget_leng(scanner), 1847| 60.8k| &val)); 1848| 60.8k| (yyval.real)=val; 1849| 60.8k|} 1850| 0|#line 1851 "/src/igraph/build/src/io/parsers/dl-parser.c" 1851| 0| break; 1852| | 1853| 128k| case 48: ------------------ | Branch (1853:3): [True: 128k, False: 16.5M] ------------------ 1854| 128k|#line 235 "/src/igraph/src/io/dl-parser.y" 1855| 128k| { 1856| 128k| igraph_integer_t trie_id; 1857| | 1858| | /* Copy label list to trie, if needed */ 1859| 128k| if (igraph_strvector_size(&context->labels) != 0) { ------------------ | Branch (1859:7): [True: 138, False: 128k] ------------------ 1860| 138| igraph_integer_t i, id, n=igraph_strvector_size(&context->labels); 1861| 547k| for (i=0; itrie, STR(context->labels, i), &id)); ------------------ | | 10| 547k| do { \ | | 11| 547k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 547k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 547k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 547k] | | | | ------------------ | | ------------------ | | 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| 547k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1863| 547k| } 1864| 138| igraph_strvector_clear(&context->labels); 1865| 138| } 1866| 128k| IGRAPH_YY_CHECK(igraph_trie_get_len(&context->trie, igraph_dl_yyget_text(scanner), ------------------ | | 10| 128k| do { \ | | 11| 128k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 128k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 128k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 128k] | | | | ------------------ | | ------------------ | | 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| 128k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1867| 128k| igraph_dl_yyget_leng(scanner), &trie_id)); 1868| 128k| IGRAPH_ASSERT(0 <= trie_id && trie_id < IGRAPH_DL_MAX_VERTEX_COUNT); ------------------ | | 1107| 128k| do { \ | | 1108| 128k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 257k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 128k] | | | | | Branch (708:50): [True: 128k, False: 0] | | | | | Branch (708:50): [True: 128k, False: 0] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 128k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1869| 128k| (yyval.integer) = trie_id; 1870| 128k| } 1871| 0|#line 1872 "/src/igraph/build/src/io/parsers/dl-parser.c" 1872| 0| break; 1873| | 1874| 108| case 49: ------------------ | Branch (1874:3): [True: 108, False: 16.7M] ------------------ 1875| 108|#line 254 "/src/igraph/src/io/dl-parser.y" 1876| 108| {} 1877| 108|#line 1878 "/src/igraph/build/src/io/parsers/dl-parser.c" 1878| 108| break; 1879| | 1880| 42| case 50: ------------------ | Branch (1880:3): [True: 42, False: 16.7M] ------------------ 1881| 42|#line 256 "/src/igraph/src/io/dl-parser.y" 1882| 42| {} 1883| 42|#line 1884 "/src/igraph/build/src/io/parsers/dl-parser.c" 1884| 42| break; 1885| | 1886| 1| case 51: ------------------ | Branch (1886:3): [True: 1, False: 16.7M] ------------------ 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| 40| case 52: ------------------ | Branch (1892:3): [True: 40, False: 16.7M] ------------------ 1893| 40|#line 258 "/src/igraph/src/io/dl-parser.y" 1894| 40| {} 1895| 40|#line 1896 "/src/igraph/build/src/io/parsers/dl-parser.c" 1896| 40| break; 1897| | 1898| 25| case 53: ------------------ | Branch (1898:3): [True: 25, False: 16.7M] ------------------ 1899| 25|#line 259 "/src/igraph/src/io/dl-parser.y" 1900| 25| {} 1901| 25|#line 1902 "/src/igraph/build/src/io/parsers/dl-parser.c" 1902| 25| break; 1903| | 1904| 0| case 54: ------------------ | Branch (1904:3): [True: 0, False: 16.7M] ------------------ 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| 271| case 55: ------------------ | Branch (1910:3): [True: 271, False: 16.7M] ------------------ 1911| 271|#line 263 "/src/igraph/src/io/dl-parser.y" 1912| 271| {} 1913| 271|#line 1914 "/src/igraph/build/src/io/parsers/dl-parser.c" 1914| 271| break; 1915| | 1916| 426| case 56: ------------------ | Branch (1916:3): [True: 426, False: 16.7M] ------------------ 1917| 426|#line 264 "/src/igraph/src/io/dl-parser.y" 1918| 426| {} 1919| 426|#line 1920 "/src/igraph/build/src/io/parsers/dl-parser.c" 1920| 426| break; 1921| | 1922| 426| case 57: ------------------ | Branch (1922:3): [True: 426, False: 16.7M] ------------------ 1923| 426|#line 267 "/src/igraph/src/io/dl-parser.y" 1924| 426| {} 1925| 426|#line 1926 "/src/igraph/build/src/io/parsers/dl-parser.c" 1926| 426| break; 1927| | 1928| 654| case 58: ------------------ | Branch (1928:3): [True: 654, False: 16.7M] ------------------ 1929| 654|#line 269 "/src/igraph/src/io/dl-parser.y" 1930| 654| { 1931| 654| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 654| do { \ | | 11| 654| igraph_error_t igraph_i_ret = (expr); \ | | 12| 654| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 654| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 5, False: 649] | | | | ------------------ | | ------------------ | | 13| 5| context->igraph_errno = igraph_i_ret; \ | | 14| 5| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 5|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 5| YYABORT; \ | | ------------------ | | | | 784| 5|#define YYABORT goto yyabortlab | | ------------------ | | 16| 5| } \ | | 17| 654| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1932| 654| igraph_dl_yyget_leng(scanner), 1933| 654| &context->from)); 1934| 649| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(context->from)); ------------------ | | 10| 649| do { \ | | 11| 649| igraph_error_t igraph_i_ret = (expr); \ | | 12| 649| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 649| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 59, False: 590] | | | | ------------------ | | ------------------ | | 13| 59| context->igraph_errno = igraph_i_ret; \ | | 14| 59| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 59|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 59| YYABORT; \ | | ------------------ | | | | 784| 59|#define YYABORT goto yyabortlab | | ------------------ | | 16| 59| } \ | | 17| 649| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1935| 649|} 1936| 590|#line 1937 "/src/igraph/build/src/io/parsers/dl-parser.c" 1937| 590| break; 1938| | 1939| 590| case 59: ------------------ | Branch (1939:3): [True: 590, False: 16.7M] ------------------ 1940| 590|#line 276 "/src/igraph/src/io/dl-parser.y" 1941| 590| {} 1942| 590|#line 1943 "/src/igraph/build/src/io/parsers/dl-parser.c" 1943| 590| break; 1944| | 1945| 635| case 60: ------------------ | Branch (1945:3): [True: 635, False: 16.7M] ------------------ 1946| 635|#line 276 "/src/igraph/src/io/dl-parser.y" 1947| 635| { 1948| 635| igraph_integer_t to = (yyvsp[0].integer); 1949| 635| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 635| do { \ | | 11| 635| igraph_error_t igraph_i_ret = (expr); \ | | 12| 635| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 635| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 54, False: 581] | | | | ------------------ | | ------------------ | | 13| 54| context->igraph_errno = igraph_i_ret; \ | | 14| 54| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 54|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 54| YYABORT; \ | | ------------------ | | | | 784| 54|#define YYABORT goto yyabortlab | | ------------------ | | 16| 54| } \ | | 17| 635| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1950| 581| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 581| do { \ | | 11| 581| igraph_error_t igraph_i_ret = (expr); \ | | 12| 581| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 581| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 581] | | | | ------------------ | | ------------------ | | 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| 581| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1951| 581| context->from-1)); 1952| 581| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, to-1)); ------------------ | | 10| 581| do { \ | | 11| 581| igraph_error_t igraph_i_ret = (expr); \ | | 12| 581| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 581| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 581] | | | | ------------------ | | ------------------ | | 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| 581| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1953| 581| } 1954| 581|#line 1955 "/src/igraph/build/src/io/parsers/dl-parser.c" 1955| 581| break; 1956| | 1957| 581| case 61: ------------------ | Branch (1957:3): [True: 331, False: 16.7M] ------------------ 1958| 331|#line 284 "/src/igraph/src/io/dl-parser.y" 1959| 331| {} 1960| 331|#line 1961 "/src/igraph/build/src/io/parsers/dl-parser.c" 1961| 331| break; 1962| | 1963| 20.9k| case 62: ------------------ | Branch (1963:3): [True: 20.9k, False: 16.6M] ------------------ 1964| 20.9k|#line 285 "/src/igraph/src/io/dl-parser.y" 1965| 20.9k| {} 1966| 20.9k|#line 1967 "/src/igraph/build/src/io/parsers/dl-parser.c" 1967| 20.9k| break; 1968| | 1969| 20.9k| case 63: ------------------ | Branch (1969:3): [True: 20.9k, False: 16.6M] ------------------ 1970| 20.9k|#line 288 "/src/igraph/src/io/dl-parser.y" 1971| 20.9k| { } 1972| 20.9k|#line 1973 "/src/igraph/build/src/io/parsers/dl-parser.c" 1973| 20.9k| break; 1974| | 1975| 21.2k| case 64: ------------------ | Branch (1975:3): [True: 21.2k, False: 16.6M] ------------------ 1976| 21.2k|#line 290 "/src/igraph/src/io/dl-parser.y" 1977| 21.2k| { 1978| 21.2k| context->from=(yyvsp[0].integer); 1979| 21.2k| } 1980| 21.2k|#line 1981 "/src/igraph/build/src/io/parsers/dl-parser.c" 1981| 21.2k| break; 1982| | 1983| 105k| case 66: ------------------ | Branch (1983:3): [True: 105k, False: 16.6M] ------------------ 1984| 105k|#line 294 "/src/igraph/src/io/dl-parser.y" 1985| 105k| { 1986| 105k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 105k| do { \ | | 11| 105k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 105k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 105k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 105k] | | | | ------------------ | | ------------------ | | 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| 105k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1987| 105k| context->from)); 1988| 105k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, (yyvsp[0].integer))); ------------------ | | 10| 105k| do { \ | | 11| 105k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 105k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 708| 105k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 105k] | | | | ------------------ | | ------------------ | | 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| 105k| } while (0) | | ------------------ | | | Branch (17:14): [Folded - Ignored] | | ------------------ ------------------ 1989| 105k| } 1990| 105k|#line 1991 "/src/igraph/build/src/io/parsers/dl-parser.c" 1991| 105k| break; 1992| | 1993| | 1994| 105k|#line 1995 "/src/igraph/build/src/io/parsers/dl-parser.c" 1995| | 1996| 1.85M| default: break; ------------------ | Branch (1996:7): [True: 1.85M, False: 14.8M] ------------------ 1997| 16.7M| } 1998| | /* User semantic actions sometimes alter yychar, and that requires 1999| | that yytoken be updated with the new translation. We take the 2000| | approach of translating immediately before every use of yytoken. 2001| | One alternative is translating here after every semantic action, 2002| | but that translation would be missed if the semantic action invokes 2003| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2004| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2005| | incorrect destructor might then be invoked immediately. In the 2006| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 2007| | to an incorrect destructor call or verbose syntax error message 2008| | before the lookahead is translated. */ 2009| 16.7M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2010| | 2011| 16.7M| YYPOPSTACK (yylen); ------------------ | | 1361| 16.7M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2012| 16.7M| yylen = 0; 2013| 16.7M| YY_STACK_PRINT (yyss, yyssp); 2014| | 2015| 16.7M| *++yyvsp = yyval; 2016| 16.7M| *++yylsp = yyloc; 2017| | 2018| | /* Now 'shift' the result of the reduction. Determine what state 2019| | that goes to, based on the state we popped back to and the rule 2020| | number reduced by. */ 2021| 16.7M| { 2022| 16.7M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 532| 16.7M|#define YYNTOKENS 17 ------------------ 2023| 16.7M| const int yyi = yypgoto[yylhs] + *yyssp; 2024| 16.7M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 529| 28.4M|#define YYLAST 118 ------------------ | Branch (2024:16): [True: 11.7M, False: 4.93M] | Branch (2024:28): [True: 11.0M, False: 707k] | Branch (2024:45): [True: 5.34M, False: 5.72M] ------------------ 2025| 16.7M| ? yytable[yyi] 2026| 16.7M| : yydefgoto[yylhs]); 2027| 16.7M| } 2028| | 2029| 16.7M| goto yynewstate; 2030| | 2031| | 2032| |/*--------------------------------------. 2033| || yyerrlab -- here on detecting error. | 2034| |`--------------------------------------*/ 2035| 843|yyerrlab: 2036| | /* Make sure we have latest lookahead translation. See comments at 2037| | user semantic actions for why this is necessary. */ 2038| 843| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 843|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 547| 1.68k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 843|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 843, False: 0] | | | Branch (547:18): [True: 843, False: 0] | | ------------------ ------------------ | Branch (2038:13): [True: 0, False: 843] ------------------ 2039| | 2040| | /* If not already recovering from an error, report this error. */ 2041| 843| if (!yyerrstatus) ------------------ | Branch (2041:7): [True: 843, False: 0] ------------------ 2042| 843| { 2043| 843| ++yynerrs; ------------------ | | 71| 843|#define yynerrs igraph_dl_yynerrs ------------------ 2044| |#if ! YYERROR_VERBOSE 2045| | yyerror (&yylloc, context, YY_("syntax error")); 2046| |#else 2047| 843|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2048| 843| yyssp, yytoken) 2049| 843| { 2050| 843| char const *yymsgp = YY_("syntax error"); ------------------ | | 334| 843|# define YY_(Msgid) Msgid ------------------ 2051| 843| int yysyntax_error_status; 2052| 843| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 2047| 843|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 2048| 843| yyssp, yytoken) ------------------ 2053| 843| if (yysyntax_error_status == 0) ------------------ | Branch (2053:13): [True: 843, False: 0] ------------------ 2054| 843| 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| 843| yyerror (&yylloc, context, yymsgp); ------------------ | | 69| 843|#define yyerror igraph_dl_yyerror ------------------ 2073| 843| if (yysyntax_error_status == 2) ------------------ | Branch (2073:13): [True: 0, False: 843] ------------------ 2074| 0| goto yyexhaustedlab; 2075| 843| } 2076| 843|# undef YYSYNTAX_ERROR 2077| 843|#endif 2078| 843| } 2079| | 2080| 843| yyerror_range[1] = yylloc; 2081| | 2082| 843| if (yyerrstatus == 3) ------------------ | Branch (2082:7): [True: 0, False: 843] ------------------ 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| 843| goto yyerrlab1; 2104| | 2105| | 2106| |/*---------------------------------------------------. 2107| || yyerrorlab -- error raised explicitly by YYERROR. | 2108| |`---------------------------------------------------*/ 2109| 843|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| 843|yyerrlab1: 2128| 843| yyerrstatus = 3; /* Each real token shifted decrements this. */ 2129| | 2130| 843| for (;;) 2131| 8.27k| { 2132| 8.27k| yyn = yypact[yystate]; 2133| 8.27k| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 8.27k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 8.27k|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (2133:11): [True: 7.18k, False: 1.09k] ------------------ 2134| 7.18k| { 2135| 7.18k| yyn += YYTERROR; ------------------ | | 808| 7.18k|#define YYTERROR 1 ------------------ 2136| 7.18k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 529| 14.3k|#define YYLAST 118 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 808| 7.18k|#define YYTERROR 1 ------------------ | Branch (2136:15): [True: 7.18k, False: 0] | Branch (2136:27): [True: 7.18k, False: 0] | Branch (2136:44): [True: 0, False: 7.18k] ------------------ 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.18k| } 2143| | 2144| | /* Pop the current state because it cannot handle the error token. */ 2145| 8.27k| if (yyssp == yyss) ------------------ | Branch (2145:11): [True: 843, False: 7.43k] ------------------ 2146| 843| YYABORT; ------------------ | | 784| 843|#define YYABORT goto yyabortlab ------------------ 2147| | 2148| 7.43k| yyerror_range[1] = *yylsp; 2149| 7.43k| yydestruct ("Error: popping", 2150| 7.43k| yystos[yystate], yyvsp, yylsp, context); 2151| 7.43k| YYPOPSTACK (1); ------------------ | | 1361| 7.43k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2152| 7.43k| yystate = *yyssp; 2153| 7.43k| YY_STACK_PRINT (yyss, yyssp); 2154| 7.43k| } 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| 892|yyacceptlab: 2177| 892| yyresult = 0; 2178| 892| goto yyreturn; 2179| | 2180| | 2181| |/*-----------------------------------. 2182| || yyabortlab -- YYABORT comes here. | 2183| |`-----------------------------------*/ 2184| 1.56k|yyabortlab: 2185| 1.56k| yyresult = 1; 2186| 1.56k| 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.45k|yyreturn: 2204| 2.45k| if (yychar != YYEMPTY) ------------------ | | 780| 2.45k|#define YYEMPTY (-2) ------------------ | Branch (2204:7): [True: 844, False: 1.60k] ------------------ 2205| 844| { 2206| | /* Make sure we have latest lookahead translation. See comments at 2207| | user semantic actions for why this is necessary. */ 2208| 844| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 844| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 844|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 844, False: 0] | | | Branch (547:18): [True: 844, False: 0] | | ------------------ ------------------ 2209| 844| yydestruct ("Cleanup: discarding lookahead", 2210| 844| yytoken, &yylval, &yylloc, context); 2211| 844| } 2212| | /* Do not reclaim the symbols of the rule whose action triggered 2213| | this YYABORT or YYACCEPT. */ 2214| 2.45k| YYPOPSTACK (yylen); ------------------ | | 1361| 2.45k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2215| 2.45k| YY_STACK_PRINT (yyss, yyssp); 2216| 10.1k| while (yyssp != yyss) ------------------ | Branch (2216:10): [True: 7.65k, False: 2.45k] ------------------ 2217| 7.65k| { 2218| 7.65k| yydestruct ("Cleanup: popping", 2219| 7.65k| yystos[+*yyssp], yyvsp, yylsp, context); 2220| 7.65k| YYPOPSTACK (1); ------------------ | | 1361| 7.65k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2221| 7.65k| } 2222| 2.45k|#ifndef yyoverflow 2223| 2.45k| if (yyss != yyssa) ------------------ | Branch (2223:7): [True: 0, False: 2.45k] ------------------ 2224| 0| YYSTACK_FREE (yyss); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2225| 2.45k|#endif 2226| 2.45k|#if YYERROR_VERBOSE 2227| 2.45k| if (yymsg != yymsgbuf) ------------------ | Branch (2227:7): [True: 0, False: 2.45k] ------------------ 2228| 0| YYSTACK_FREE (yymsg); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2229| 2.45k|#endif 2230| 2.45k| return yyresult; 2231| 0|} igraph_dl_yyerror: 2237| 1.50k| const char *s) { 2238| 1.50k| snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1, 2239| 1.50k| "Parse error in DL file, line %i (%s)", 2240| 1.50k| locp->first_line, s); 2241| 1.50k| return 0; 2242| 1.50k|} dl-parser.c:yysyntax_error: 1131| 843|{ 1132| 843| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1133| | /* Internationalized format string. */ 1134| 843| const char *yyformat = YY_NULLPTR; ------------------ | | 138| 843|# define YY_NULLPTR ((void*)0) ------------------ 1135| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1136| | one per "expected"). */ 1137| 843| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1138| | /* Actual size of YYARG. */ 1139| 843| int yycount = 0; 1140| | /* Cumulated lengths of YYARG. */ 1141| 843| YYPTRDIFF_T yysize = 0; ------------------ | | 285| 843|# 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| 843| if (yytoken != YYEMPTY) ------------------ | | 780| 843|#define YYEMPTY (-2) ------------------ | Branch (1166:7): [True: 843, False: 0] ------------------ 1167| 843| { 1168| 843| int yyn = yypact[+*yyssp]; 1169| 843| YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 285| 843|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 138| 843|# define YY_NULLPTR ((void*)0) ------------------ 1170| 843| yysize = yysize0; 1171| 843| yyarg[yycount++] = yytname[yytoken]; 1172| 843| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 843| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 843|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (1172:11): [True: 843, False: 0] ------------------ 1173| 843| { 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| 843| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1177:26): [True: 0, False: 843] ------------------ 1178| | /* Stay within bounds of both yycheck and yytname. */ 1179| 843| int yychecklim = YYLAST - yyn + 1; ------------------ | | 529| 843|#define YYLAST 118 ------------------ 1180| 843| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 843|#define YYNTOKENS 17 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 843|#define YYNTOKENS 17 ------------------ | Branch (1180:24): [True: 0, False: 843] ------------------ 1181| 843| int yyx; 1182| | 1183| 15.1k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1183:32): [True: 14.2k, False: 832] ------------------ 1184| 14.2k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 808| 15.7k|#define YYTERROR 1 ------------------ | Branch (1184:17): [True: 1.42k, False: 12.8k] | Branch (1184:46): [True: 1.42k, False: 0] ------------------ 1185| 14.2k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 637| 0| 0 ------------------ | Branch (1185:20): [Folded - Ignored] ------------------ 1186| 1.42k| { 1187| 1.42k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1187:21): [True: 11, False: 1.41k] ------------------ 1188| 11| { 1189| 11| yycount = 1; 1190| 11| yysize = yysize0; 1191| 11| break; 1192| 11| } 1193| 1.41k| yyarg[yycount++] = yytname[yyx]; 1194| 1.41k| { 1195| 1.41k| YYPTRDIFF_T yysize1 ------------------ | | 285| 1.41k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1196| 1.41k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 138| 1.41k|# define YY_NULLPTR ((void*)0) ------------------ 1197| 1.41k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 1.41k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 1.41k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 2.82k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1197:23): [True: 1.41k, False: 0] | Branch (1197:44): [True: 1.41k, False: 0] ------------------ 1198| 1.41k| yysize = yysize1; 1199| 0| else 1200| 0| return 2; 1201| 1.41k| } 1202| 1.41k| } 1203| 843| } 1204| 843| } 1205| | 1206| 843| switch (yycount) 1207| 843| { 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: 843] ------------------ 1213| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1209| 0| case N: \ | | ------------------ | | | Branch (1209:7): [True: 0, False: 843] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1214| 11| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1209| 11| case N: \ | | ------------------ | | | Branch (1209:7): [True: 11, False: 832] | | ------------------ | | 1210| 11| yyformat = S; \ | | 1211| 11| break ------------------ 1215| 325| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1209| 325| case N: \ | | ------------------ | | | Branch (1209:7): [True: 325, False: 518] | | ------------------ | | 1210| 325| yyformat = S; \ | | 1211| 325| break ------------------ 1216| 477| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1209| 477| case N: \ | | ------------------ | | | Branch (1209:7): [True: 477, False: 366] | | ------------------ | | 1210| 477| yyformat = S; \ | | 1211| 477| break ------------------ 1217| 30| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1209| 30| case N: \ | | ------------------ | | | Branch (1209:7): [True: 30, False: 813] | | ------------------ | | 1210| 30| yyformat = S; \ | | 1211| 30| break ------------------ 1218| 843| 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: 843] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1219| 843|# undef YYCASE_ 1220| 843| } 1221| | 1222| 843| { 1223| | /* Don't count the "%s"s in the final size, but reserve room for 1224| | the terminator. */ 1225| 843| YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 285| 843|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 1035| 843|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 843|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1226| 843| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 843|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 843| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 1.68k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1226:9): [True: 843, False: 0] | Branch (1226:30): [True: 843, False: 0] ------------------ 1227| 843| yysize = yysize1; 1228| 0| else 1229| 0| return 2; 1230| 843| } 1231| | 1232| 843| if (*yymsg_alloc < yysize) ------------------ | Branch (1232:7): [True: 0, False: 843] ------------------ 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| 843| { 1245| 843| char *yyp = *yymsg; 1246| 843| int yyi = 0; 1247| 36.2k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1247:12): [True: 35.4k, False: 843] ------------------ 1248| 35.4k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1248:11): [True: 2.21k, False: 33.2k] | Branch (1248:26): [True: 2.21k, False: 0] | Branch (1248:48): [True: 2.21k, False: 0] ------------------ 1249| 2.21k| { 1250| 2.21k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1251| 2.21k| yyformat += 2; 1252| 2.21k| } 1253| 33.2k| else 1254| 33.2k| { 1255| 33.2k| ++yyp; 1256| 33.2k| ++yyformat; 1257| 33.2k| } 1258| 843| } 1259| 843| return 0; 1260| 843|} dl-parser.c:yytnamerr: 1079| 4.46k|{ 1080| 4.46k| if (*yystr == '"') ------------------ | Branch (1080:7): [True: 3.22k, False: 1.24k] ------------------ 1081| 3.22k| { 1082| 3.22k| YYPTRDIFF_T yyn = 0; ------------------ | | 285| 3.22k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1083| 3.22k| char const *yyp = yystr; 1084| | 1085| 3.22k| for (;;) 1086| 28.2k| switch (*++yyp) 1087| 28.2k| { 1088| 0| case '\'': ------------------ | Branch (1088:11): [True: 0, False: 28.2k] ------------------ 1089| 0| case ',': ------------------ | Branch (1089:11): [True: 0, False: 28.2k] ------------------ 1090| 0| goto do_not_strip_quotes; 1091| | 1092| 0| case '\\': ------------------ | Branch (1092:11): [True: 0, False: 28.2k] ------------------ 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| 25.0k| default: ------------------ | Branch (1099:11): [True: 25.0k, False: 3.22k] ------------------ 1100| 25.0k| if (yyres) ------------------ | Branch (1100:17): [True: 12.3k, False: 12.6k] ------------------ 1101| 12.3k| yyres[yyn] = *yyp; 1102| 25.0k| yyn++; 1103| 25.0k| break; 1104| | 1105| 3.22k| case '"': ------------------ | Branch (1105:11): [True: 3.22k, False: 25.0k] ------------------ 1106| 3.22k| if (yyres) ------------------ | Branch (1106:17): [True: 1.59k, False: 1.63k] ------------------ 1107| 1.59k| yyres[yyn] = '\0'; 1108| 3.22k| return yyn; 1109| 28.2k| } 1110| 0| do_not_strip_quotes: ; 1111| 0| } 1112| | 1113| 1.24k| if (yyres) ------------------ | Branch (1113:7): [True: 615, False: 626] ------------------ 1114| 615| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1051| 615|# define yystpcpy stpcpy ------------------ 1115| 626| else 1116| 626| return yystrlen (yystr); ------------------ | | 1035| 626|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 626|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1117| 1.24k|} dl-parser.c:yydestruct: 1269| 15.9k|{ 1270| 15.9k| YYUSE (yyvaluep); ------------------ | | 356| 15.9k|# define YYUSE(E) ((void) (E)) ------------------ 1271| 15.9k| YYUSE (yylocationp); ------------------ | | 356| 15.9k|# define YYUSE(E) ((void) (E)) ------------------ 1272| 15.9k| YYUSE (context); ------------------ | | 356| 15.9k|# define YYUSE(E) ((void) (E)) ------------------ 1273| 15.9k| if (!yymsg) ------------------ | Branch (1273:7): [True: 0, False: 15.9k] ------------------ 1274| 0| yymsg = "Deleting"; 1275| 15.9k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1276| | 1277| 15.9k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1278| 15.9k| YYUSE (yytype); ------------------ | | 356| 15.9k|# define YYUSE(E) ((void) (E)) ------------------ 1279| 15.9k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1280| 15.9k|} dl-parser.c:igraph_i_dl_add_str: 2245| 1.81M| igraph_i_dl_parsedata_t *context) { 2246| 1.81M| IGRAPH_CHECK(igraph_strvector_push_back_len(&context->labels, newstr, length)); ------------------ | | 752| 1.81M| do { \ | | 753| 1.81M| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.81M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.81M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.81M] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.81M| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2247| 1.81M| return IGRAPH_SUCCESS; 2248| 1.81M|} dl-parser.c:igraph_i_dl_add_edge: 2251| 1.98M| 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| 1.98M| IGRAPH_CHECK(igraph_vector_int_push_back(&context->edges, from)); ------------------ | | 752| 1.98M| do { \ | | 753| 1.98M| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.98M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.98M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.98M] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.98M| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2255| 1.98M| IGRAPH_CHECK(igraph_vector_int_push_back(&context->edges, to)); ------------------ | | 752| 1.98M| do { \ | | 753| 1.98M| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.98M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.98M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.98M] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.98M| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2256| 1.98M| return IGRAPH_SUCCESS; 2257| 1.98M|} dl-parser.c:igraph_i_dl_add_edge_w: 2261| 60.5k| igraph_i_dl_parsedata_t *context) { 2262| 60.5k| igraph_integer_t n=igraph_vector_size(&context->weights); 2263| 60.5k| igraph_integer_t n2=igraph_vector_int_size(&context->edges)/2; 2264| 60.5k| if (n != n2) { ------------------ | Branch (2264:7): [True: 55.7k, False: 4.75k] ------------------ 2265| 55.7k| IGRAPH_CHECK(igraph_vector_resize(&context->weights, n2)); ------------------ | | 752| 55.7k| do { \ | | 753| 55.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 55.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 55.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 55.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 55.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2266| 1.98M| for (; nweights)[n]=IGRAPH_NAN; ------------------ | | 69| 1.92M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context->weights)[n]=IGRAPH_NAN; ------------------ | | 153| 1.92M|#define IGRAPH_NAN ((double)NAN) ------------------ 2268| 1.92M| } 2269| 55.7k| } 2270| 60.5k| IGRAPH_CHECK(igraph_i_dl_add_edge(from, to, context)); ------------------ | | 752| 60.5k| do { \ | | 753| 60.5k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 60.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 60.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 60.5k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 60.5k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2271| 60.5k| IGRAPH_CHECK(igraph_vector_push_back(&context->weights, weight)); ------------------ | | 752| 60.5k| do { \ | | 753| 60.5k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 60.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 60.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 60.5k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 60.5k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2272| 60.5k| return IGRAPH_SUCCESS; 2273| 60.5k|} dl-parser.c:igraph_i_dl_check_vid: 2277| 3.97M|static igraph_error_t igraph_i_dl_check_vid(igraph_integer_t dl_vid) { 2278| 3.97M| if (dl_vid < 1) { ------------------ | Branch (2278:9): [True: 309, False: 3.97M] ------------------ 2279| 309| IGRAPH_ERRORF("Invalid vertex index in DL file: %" IGRAPH_PRId ".", ------------------ | | 550| 309| do { \ | | 551| 309| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 309| igraph_errno, __VA_ARGS__) ; \ | | 553| 309| return igraph_errno; \ | | 554| 309| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 2280| 309| IGRAPH_EINVAL, dl_vid); 2281| 309| } 2282| 3.97M| if (dl_vid > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 3.97M|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (2282:9): [True: 301, False: 3.97M] ------------------ 2283| 301| IGRAPH_ERRORF("Vertex index too large in DL file: %" IGRAPH_PRId ".", ------------------ | | 550| 301| do { \ | | 551| 301| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 301| igraph_errno, __VA_ARGS__) ; \ | | 553| 301| return igraph_errno; \ | | 554| 301| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 2284| 301| IGRAPH_EINVAL, dl_vid); 2285| 301| } 2286| 3.97M| return IGRAPH_SUCCESS; 2287| 3.97M|} LLVMFuzzerTestOneInput: 25| 2.45k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 26| | 27| 2.45k| igraph_set_error_handler(igraph_error_handler_ignore); 28| 2.45k| igraph_set_warning_handler(igraph_warning_handler_ignore); 29| | 30| | // Turn on attribute handling 31| 2.45k| igraph_set_attribute_table(&igraph_cattribute_table); 32| | 33| | // Create input file 34| 2.45k| char filename[256]; 35| 2.45k| sprintf(filename, "/tmp/libfuzzer.dl"); 36| 2.45k| FILE *fp = fopen(filename, "wb"); 37| 2.45k| if (!fp) return 0; ------------------ | Branch (37:9): [True: 0, False: 2.45k] ------------------ 38| 2.45k| fwrite(data, size, 1, fp); 39| 2.45k| fclose(fp); 40| | 41| | // Read input file 42| 2.45k| FILE *ifile; 43| 2.45k| ifile = fopen("/tmp/libfuzzer.dl", "r"); 44| 2.45k| if(ifile == 0){ ------------------ | Branch (44:8): [True: 0, False: 2.45k] ------------------ 45| 0| remove(filename); 46| 0| return 0; 47| 0| } 48| | 49| | // Do the fuzzing 50| 2.45k| igraph_t g; 51| 2.45k| if (igraph_read_graph_dl(&g, ifile, IGRAPH_DIRECTED) == IGRAPH_SUCCESS) { ------------------ | Branch (51:9): [True: 468, False: 1.98k] ------------------ 52| | // Clean up 53| 468| igraph_destroy(&g); 54| 468| } 55| | 56| | // no need to call igraph_destroy() if igraph_read_graph_dl() returns an 57| | // error code as we don't have a valid graph object in that case 58| | 59| 2.45k| fclose(ifile); 60| 2.45k| remove(filename); 61| | 62| 2.45k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY); ------------------ | | 1107| 2.45k| do { \ | | 1108| 2.45k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | ------------------ | | | | 468| 0|# define IGRAPH_FILE_BASENAME __FILE__ | | ------------------ | | 1110| 0| } \ | | 1111| 2.45k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 63| | 64| 2.45k| return 0; 65| 2.45k|} igraph_error: 168| 3.27k| igraph_error_t igraph_errno) { 169| | 170| 3.27k| if (igraph_i_error_handler) { ------------------ | Branch (170:9): [True: 3.27k, False: 0] ------------------ 171| 3.27k| igraph_i_error_handler(reason, file, line, igraph_errno); 172| 3.27k|#ifndef USING_R 173| 3.27k| } else { 174| 0| igraph_error_handler_abort(reason, file, line, igraph_errno); 175| 0|#endif 176| 0| } 177| 3.27k| return igraph_errno; 178| 3.27k|} igraph_errorf: 181| 663| igraph_error_t igraph_errno, ...) { 182| 663| va_list ap; 183| 663| va_start(ap, igraph_errno); 184| 663| vsnprintf(igraph_i_errormsg_buffer, 185| 663| sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap); 186| 663| va_end(ap); 187| 663| return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno); 188| 663|} igraph_error_handler_ignore: 207| 3.27k| int line, igraph_error_t igraph_errno) { 208| 3.27k| IGRAPH_UNUSED(reason); ------------------ | | 12| 3.27k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 209| 3.27k| IGRAPH_UNUSED(file); ------------------ | | 12| 3.27k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 210| 3.27k| IGRAPH_UNUSED(line); ------------------ | | 12| 3.27k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 211| 3.27k| IGRAPH_UNUSED(igraph_errno); ------------------ | | 12| 3.27k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 212| | 213| 3.27k| IGRAPH_FINALLY_FREE(); 214| 3.27k|} igraph_set_error_handler: 225| 2.45k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) { 226| 2.45k| igraph_error_handler_t *previous_handler = igraph_i_error_handler; 227| 2.45k| igraph_i_error_handler = new_handler; 228| 2.45k| return previous_handler; 229| 2.45k|} IGRAPH_FINALLY_REAL: 247| 274k|void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) { 248| 274k| int no = igraph_i_finally_stack_size; 249| 274k| if (no < 0) { ------------------ | Branch (249:9): [True: 0, False: 274k] ------------------ 250| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 251| 0| igraph_i_reset_finally_stack(); 252| 0| IGRAPH_FATALF("Corrupt finally stack: it contains %d elements.", no); ------------------ | | 1058| 0| do { \ | | 1059| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 1060| 0| __VA_ARGS__); \ | | 1061| 0| } while (0) | | ------------------ | | | Branch (1061:14): [Folded - Ignored] | | ------------------ ------------------ 253| 0| } 254| 274k| if (no >= (int) (sizeof(igraph_i_finally_stack) / sizeof(igraph_i_finally_stack[0]))) { ------------------ | Branch (254:9): [True: 0, False: 274k] ------------------ 255| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 256| 0| igraph_i_reset_finally_stack(); 257| 0| IGRAPH_FATALF("Finally stack too large: it contains %d elements.", no); ------------------ | | 1058| 0| do { \ | | 1059| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 1060| 0| __VA_ARGS__); \ | | 1061| 0| } while (0) | | ------------------ | | | Branch (1061:14): [Folded - Ignored] | | ------------------ ------------------ 258| 0| } 259| 274k| igraph_i_finally_stack[no].ptr = ptr; 260| 274k| igraph_i_finally_stack[no].func = func; 261| 274k| igraph_i_finally_stack[no].level = igraph_i_finally_stack_level; 262| 274k| igraph_i_finally_stack_size++; 263| 274k|} IGRAPH_FINALLY_CLEAN: 265| 162k|void IGRAPH_FINALLY_CLEAN(int minus) { 266| 162k| igraph_i_finally_stack_size -= minus; 267| 162k| if (igraph_i_finally_stack_size < 0) { ------------------ | Branch (267:9): [True: 0, False: 162k] ------------------ 268| 0| int left = igraph_i_finally_stack_size + minus; 269| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 270| 0| igraph_i_reset_finally_stack(); 271| 0| IGRAPH_FATALF("Corrupt finally stack: trying to pop %d element(s) when only %d left.", minus, left); ------------------ | | 1058| 0| do { \ | | 1059| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 1060| 0| __VA_ARGS__); \ | | 1061| 0| } while (0) | | ------------------ | | | Branch (1061:14): [Folded - Ignored] | | ------------------ ------------------ 272| 0| } 273| 162k|} IGRAPH_FINALLY_FREE: 275| 3.27k|void IGRAPH_FINALLY_FREE(void) { 276| 14.0k| for (; igraph_i_finally_stack_size > 0; igraph_i_finally_stack_size--) { ------------------ | Branch (276:12): [True: 11.6k, False: 2.40k] ------------------ 277| 11.6k| int p = igraph_i_finally_stack_size - 1; 278| | /* Call destructors only up to the current level */ 279| 11.6k| if (igraph_i_finally_stack[p].level < igraph_i_finally_stack_level) { ------------------ | Branch (279:13): [True: 862, False: 10.7k] ------------------ 280| 862| break; 281| 862| } 282| 10.7k| igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr); 283| 10.7k| } 284| 3.27k|} IGRAPH_FINALLY_STACK_SIZE: 286| 2.45k|int IGRAPH_FINALLY_STACK_SIZE(void) { 287| 2.45k| return igraph_i_finally_stack_size; 288| 2.45k|} IGRAPH_FINALLY_ENTER: 304| 680k|void IGRAPH_FINALLY_ENTER(void) { 305| 680k| int no = igraph_i_finally_stack_size; 306| | /* Level indices must always be in increasing order in the finally stack */ 307| 680k| if (no > 0 && igraph_i_finally_stack[no-1].level > igraph_i_finally_stack_level) { ------------------ | Branch (307:9): [True: 680k, False: 0] | Branch (307:19): [True: 0, False: 680k] ------------------ 308| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 309| 0| igraph_i_reset_finally_stack(); 310| 0| IGRAPH_FATAL("Corrupt finally stack: cannot create new finally stack level before last one is freed."); ------------------ | | 1078| 0| do { \ | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1080| 0| } while (0) | | ------------------ | | | Branch (1080:14): [Folded - Ignored] | | ------------------ ------------------ 311| 0| } 312| 680k| igraph_i_finally_stack_level++; 313| 680k|} IGRAPH_FINALLY_EXIT: 326| 680k|void IGRAPH_FINALLY_EXIT(void) { 327| 680k| igraph_i_finally_stack_level--; 328| 680k| if (igraph_i_finally_stack_level < 0) { ------------------ | Branch (328:9): [True: 0, False: 680k] ------------------ 329| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 330| 0| igraph_i_reset_finally_stack(); 331| 0| IGRAPH_FATAL("Corrupt finally stack: trying to exit outermost finally stack level."); ------------------ | | 1078| 0| do { \ | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1080| 0| } while (0) | | ------------------ | | | Branch (1080:14): [Folded - Ignored] | | ------------------ ------------------ 332| 0| } 333| 680k|} igraph_warning_handler_ignore: 353| 389|void igraph_warning_handler_ignore(const char *reason, const char *file, int line) { 354| 389| IGRAPH_UNUSED(reason); ------------------ | | 12| 389|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 355| 389| IGRAPH_UNUSED(file); ------------------ | | 12| 389|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 356| 389| IGRAPH_UNUSED(line); ------------------ | | 12| 389|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 357| 389|} igraph_warning: 380| 389|void igraph_warning(const char *reason, const char *file, int line) { 381| | 382| 389| if (igraph_i_warning_handler) { ------------------ | Branch (382:9): [True: 389, False: 0] ------------------ 383| 389| igraph_i_warning_handler(reason, file, line); 384| 389|#ifndef USING_R 385| 389| } else { 386| 0| igraph_warning_handler_print(reason, file, line); 387| 0|#endif 388| 0| } 389| 389|} igraph_set_warning_handler: 401| 2.45k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) { 402| 2.45k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler; 403| 2.45k| igraph_i_warning_handler = new_handler; 404| 2.45k| return previous_handler; 405| 2.45k|} igraph_strvector_init: 71| 29.0k|igraph_error_t igraph_strvector_init(igraph_strvector_t *sv, igraph_integer_t size) { 72| | 73| 29.0k| sv->stor_begin = IGRAPH_CALLOC(size, char*); ------------------ | | 32| 29.0k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 21.4k, False: 7.56k] | | ------------------ ------------------ 74| 29.0k| IGRAPH_CHECK_OOM(sv->stor_begin, "Cannot initialize string vector."); ------------------ | | 807| 29.0k| do { \ | | 808| 29.0k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 29.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.0k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 29.0k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 75| | 76| 63.4k| for (igraph_integer_t i = 0; i < size; i++) { ------------------ | Branch (76:34): [True: 34.4k, False: 29.0k] ------------------ 77| 34.4k| sv->stor_begin[i] = IGRAPH_CALLOC(1, char); ------------------ | | 32| 34.4k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 78| 34.4k| if (sv->stor_begin[i] == NULL) { ------------------ | Branch (78:13): [True: 0, False: 34.4k] ------------------ 79| | /* LCOV_EXCL_START */ 80| 0| for (igraph_integer_t j = 0; j < i; j++) { ------------------ | Branch (80:42): [True: 0, False: 0] ------------------ 81| 0| IGRAPH_FREE(sv->stor_begin[j]); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 82| 0| } 83| 0| IGRAPH_FREE(sv->stor_begin); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 84| 0| IGRAPH_ERROR("Cannot initialize string vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 85| | /* LCOV_EXCL_STOP */ 86| 0| } 87| 34.4k| sv->stor_begin[i][0] = '\0'; 88| 34.4k| } 89| | 90| 29.0k| sv->stor_end = sv->stor_begin + size; 91| 29.0k| sv->end = sv->stor_end; 92| | 93| 29.0k| return IGRAPH_SUCCESS; 94| 29.0k|} igraph_strvector_destroy: 109| 29.0k|void igraph_strvector_destroy(igraph_strvector_t *sv) { 110| 29.0k| char **ptr; 111| 29.0k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 1107| 29.0k| do { \ | | 1108| 29.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 29.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 29.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 112| 29.0k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 1107| 29.0k| do { \ | | 1108| 29.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 29.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 29.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 113| 1.45M| for (ptr = sv->stor_begin; ptr < sv->end; ptr++) { ------------------ | Branch (113:32): [True: 1.42M, False: 29.0k] ------------------ 114| 1.42M| IGRAPH_FREE(*ptr); ------------------ | | 35| 1.42M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 115| 1.42M| } 116| 29.0k| IGRAPH_FREE(sv->stor_begin); ------------------ | | 35| 29.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 117| 29.0k|} igraph_strvector_get: 133| 9.37M|const char *igraph_strvector_get(const igraph_strvector_t *sv, igraph_integer_t idx) { 134| 9.37M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 1107| 9.37M| do { \ | | 1108| 9.37M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 9.37M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.37M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 9.37M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 135| 9.37M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 1107| 9.37M| do { \ | | 1108| 9.37M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 9.37M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.37M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 9.37M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 136| 9.37M| IGRAPH_ASSERT(sv->stor_begin[idx] != NULL); ------------------ | | 1107| 9.37M| do { \ | | 1108| 9.37M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 9.37M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.37M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 9.37M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 137| 9.37M| return sv->stor_begin[idx]; 138| 9.37M|} igraph_strvector_set: 158| 53.3k| const char *value) { 159| 53.3k| return igraph_strvector_set_len(sv, idx, value, strlen(value)); 160| 53.3k|} igraph_strvector_set_len: 180| 53.3k| const char *value, size_t len) { 181| 53.3k| char *tmp; 182| | 183| 53.3k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 1107| 53.3k| do { \ | | 1108| 53.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 53.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 53.3k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 53.3k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 184| 53.3k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 1107| 53.3k| do { \ | | 1108| 53.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 53.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 53.3k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 53.3k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 185| 53.3k| IGRAPH_ASSERT(sv->stor_begin[idx] != NULL); ------------------ | | 1107| 53.3k| do { \ | | 1108| 53.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 53.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 53.3k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 53.3k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 186| | 187| 53.3k| tmp = IGRAPH_REALLOC(sv->stor_begin[idx], len + 1, char); ------------------ | | 34| 53.3k|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 53.3k, False: 0] | | ------------------ ------------------ 188| 53.3k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new item in string vector."); ------------------ | | 807| 53.3k| do { \ | | 808| 53.3k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 53.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 53.3k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 53.3k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 189| | 190| 53.3k| sv->stor_begin[idx] = tmp; 191| 53.3k| memcpy(sv->stor_begin[idx], value, len * sizeof(char)); 192| 53.3k| sv->stor_begin[idx][len] = '\0'; 193| | 194| 53.3k| return IGRAPH_SUCCESS; 195| 53.3k|} igraph_strvector_append: 322| 57| const igraph_strvector_t *from) { 323| 57| igraph_integer_t len1 = igraph_strvector_size(to), len2 = igraph_strvector_size(from); 324| 57| igraph_integer_t newlen; 325| 57| igraph_bool_t error = false; 326| 57| char *tmp; 327| | 328| 57| IGRAPH_SAFE_ADD(len1, len2, &newlen); ------------------ | | 47| 57| do { \ | | 48| 57| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 57| igraph_integer_t _safe_sum; \ | | 50| 57| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 57] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 57| *(res) = _safe_sum; \ | | 54| 57| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 329| 57| IGRAPH_CHECK(igraph_strvector_reserve(to, newlen)); ------------------ | | 752| 57| do { \ | | 753| 57| igraph_error_t igraph_i_ret = (expr); \ | | 754| 57| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 57| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 57] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 57| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 330| | 331| 66.1k| for (igraph_integer_t i = 0; i < len2; i++) { ------------------ | Branch (331:34): [True: 66.0k, False: 57] ------------------ 332| 66.0k| tmp = strdup(igraph_strvector_get(from, i)); 333| 66.0k| if (!tmp) { ------------------ | Branch (333:13): [True: 0, False: 66.0k] ------------------ 334| 0| error = true; 335| 0| break; 336| 66.0k| } else { 337| 66.0k| *(to->end) = tmp; 338| 66.0k| to->end++; 339| 66.0k| } 340| 66.0k| } 341| | 342| 57| if (error) { ------------------ | Branch (342:9): [True: 0, False: 57] ------------------ 343| 0| igraph_strvector_resize(to, len1); /* always shrinks */ 344| 0| IGRAPH_ERROR("Cannot append string vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 345| 0| } 346| | 347| 57| return IGRAPH_SUCCESS; 348| 57|} igraph_strvector_clear: 402| 138|void igraph_strvector_clear(igraph_strvector_t *sv) { 403| 138| igraph_integer_t n = igraph_strvector_size(sv); 404| | 405| 547k| for (igraph_integer_t i = 0; i < n; i++) { ------------------ | Branch (405:34): [True: 547k, False: 138] ------------------ 406| 547k| IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 35| 547k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 407| 547k| } 408| 138| sv->end = sv->stor_begin; 409| 138|} igraph_strvector_resize: 428| 633k|igraph_error_t igraph_strvector_resize(igraph_strvector_t *sv, igraph_integer_t newsize) { 429| 633k| igraph_integer_t toadd = newsize - igraph_strvector_size(sv); 430| 633k| igraph_integer_t oldsize = igraph_strvector_size(sv); 431| | 432| 633k| if (newsize < oldsize) { ------------------ | Branch (432:9): [True: 633k, False: 144] ------------------ 433| 1.26M| for (igraph_integer_t i = newsize; i < oldsize; i++) { ------------------ | Branch (433:44): [True: 633k, False: 633k] ------------------ 434| 633k| IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 35| 633k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 435| 633k| } 436| 633k| sv->end = sv->stor_begin + newsize; 437| 633k| } else if (newsize > oldsize) { ------------------ | Branch (437:16): [True: 0, False: 144] ------------------ 438| 0| IGRAPH_CHECK(igraph_strvector_reserve(sv, newsize)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 439| | 440| 0| for (igraph_integer_t i = 0; i < toadd; i++) { ------------------ | Branch (440:38): [True: 0, False: 0] ------------------ 441| 0| sv->stor_begin[oldsize + i] = IGRAPH_CALLOC(1, char); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 442| 0| if (sv->stor_begin[oldsize + i] == NULL) { ------------------ | Branch (442:17): [True: 0, False: 0] ------------------ 443| | /* LCOV_EXCL_START */ 444| 0| for (igraph_integer_t j = 0; j < i; j++) { ------------------ | Branch (444:46): [True: 0, False: 0] ------------------ 445| 0| IGRAPH_FREE(sv->stor_begin[oldsize + j]); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 446| 0| } 447| 0| IGRAPH_ERROR("Cannot resize string vector.", IGRAPH_ENOMEM); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 448| | /* LCOV_EXCL_STOP */ 449| 0| } 450| 0| sv->stor_begin[oldsize + i][0] = '\0'; 451| 0| } 452| 0| sv->end = sv->stor_begin + newsize; 453| 0| } 454| | 455| 633k| return IGRAPH_SUCCESS; 456| 633k|} igraph_strvector_capacity: 469| 12.0k|igraph_integer_t igraph_strvector_capacity(const igraph_strvector_t *sv) { 470| 12.0k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 1107| 12.0k| do { \ | | 1108| 12.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 12.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 12.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 12.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 471| 12.0k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 1107| 12.0k| do { \ | | 1108| 12.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 12.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 12.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 12.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 472| 12.0k| return sv->stor_end - sv->stor_begin; 473| 12.0k|} igraph_strvector_reserve: 502| 11.9k|igraph_error_t igraph_strvector_reserve(igraph_strvector_t *sv, igraph_integer_t capacity) { 503| 11.9k| igraph_integer_t current_capacity = igraph_strvector_capacity(sv); 504| 11.9k| char **tmp; 505| | 506| 11.9k| if (capacity <= current_capacity) { ------------------ | Branch (506:9): [True: 0, False: 11.9k] ------------------ 507| 0| return IGRAPH_SUCCESS; 508| 0| } 509| | 510| 11.9k| tmp = IGRAPH_REALLOC(sv->stor_begin, capacity, char *); ------------------ | | 34| 11.9k|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 11.9k, False: 0] | | ------------------ ------------------ 511| 11.9k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new items in string vector."); ------------------ | | 807| 11.9k| do { \ | | 808| 11.9k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 11.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.9k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 11.9k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 512| | 513| 11.9k| sv->end = tmp + (sv->end - sv->stor_begin); 514| 11.9k| sv->stor_begin = tmp; 515| 11.9k| sv->stor_end = sv->stor_begin + capacity; 516| | 517| 11.9k| return IGRAPH_SUCCESS; 518| 11.9k|} igraph_strvector_size: 562| 4.52M|igraph_integer_t igraph_strvector_size(const igraph_strvector_t *sv) { 563| 4.52M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 1107| 4.52M| do { \ | | 1108| 4.52M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 4.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 4.52M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 4.52M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 564| 4.52M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 1107| 4.52M| do { \ | | 1108| 4.52M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 4.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 4.52M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 4.52M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 565| 4.52M| return sv->end - sv->stor_begin; 566| 4.52M|} igraph_strvector_push_back: 604| 695k|igraph_error_t igraph_strvector_push_back(igraph_strvector_t *sv, const char *value) { 605| 695k| IGRAPH_CHECK(igraph_i_strvector_expand_if_full(sv)); ------------------ | | 752| 695k| do { \ | | 753| 695k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 695k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 695k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 695k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 695k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 606| 695k| char *tmp = strdup(value); 607| 695k| IGRAPH_CHECK_OOM(tmp, "Cannot push new string to string vector."); ------------------ | | 807| 695k| do { \ | | 808| 695k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 695k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 695k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 695k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 608| 695k| *sv->end = tmp; 609| 695k| sv->end++; 610| | 611| 695k| return IGRAPH_SUCCESS; 612| 695k|} igraph_strvector_push_back_len: 630| 1.81M| const char *value, igraph_integer_t len) { 631| | 632| 1.81M| IGRAPH_CHECK(igraph_i_strvector_expand_if_full(sv)); ------------------ | | 752| 1.81M| do { \ | | 753| 1.81M| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.81M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.81M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.81M] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.81M| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 633| 1.81M| char *tmp = strndup(value, len); 634| 1.81M| if (! tmp) { ------------------ | Branch (634:9): [True: 0, False: 1.81M] ------------------ 635| 0| IGRAPH_ERROR("Cannot add string to string vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 636| 0| } 637| 1.81M| *sv->end = tmp; 638| 1.81M| sv->end++; 639| | 640| 1.81M| return IGRAPH_SUCCESS; 641| 1.81M|} strvector.c:igraph_i_strvector_expand_if_full: 572| 2.50M|static igraph_error_t igraph_i_strvector_expand_if_full(igraph_strvector_t *sv) { 573| 2.50M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 1107| 2.50M| do { \ | | 1108| 2.50M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.50M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.50M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.50M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 574| 2.50M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 1107| 2.50M| do { \ | | 1108| 2.50M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.50M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.50M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.50M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 575| | 576| 2.50M| if (sv->stor_end == sv->end) { ------------------ | Branch (576:9): [True: 11.8k, False: 2.49M] ------------------ 577| 11.8k| igraph_integer_t old_size = igraph_strvector_size(sv); 578| 11.8k| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 11.8k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 11.8k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (578:37): [True: 11.8k, False: 0] ------------------ 579| 11.8k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 78| 11.8k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (579:13): [True: 0, False: 11.8k] ------------------ 580| 0| IGRAPH_ERROR("Cannot add new item to string vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 581| 0| } 582| 11.8k| if (new_size == 0) { ------------------ | Branch (582:13): [True: 1.11k, False: 10.7k] ------------------ 583| 1.11k| new_size = 1; 584| 1.11k| } 585| 11.8k| IGRAPH_CHECK(igraph_strvector_reserve(sv, new_size)); ------------------ | | 752| 11.8k| do { \ | | 753| 11.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 11.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 11.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 11.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 586| 11.8k| } 587| | 588| 2.50M| return IGRAPH_SUCCESS; 589| 2.50M|} igraph_trie_init: 61| 2.45k|igraph_error_t igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) { 62| 2.45k| t->maxvalue = -1; 63| 2.45k| t->storekeys = storekeys; 64| 2.45k| IGRAPH_CHECK(igraph_i_trie_init_node(&t->node)); ------------------ | | 752| 2.45k| do { \ | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 2.45k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 65| 2.45k| IGRAPH_FINALLY(igraph_i_trie_destroy_node, &t->node); ------------------ | | 695| 2.45k| do { \ | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | 699| 2.45k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 2.45k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 66| 2.45k| if (storekeys) { ------------------ | Branch (66:9): [True: 2.45k, False: 0] ------------------ 67| 2.45k| IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0)); ------------------ | | 752| 2.45k| do { \ | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 2.45k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 68| 2.45k| } 69| | 70| 2.45k| IGRAPH_FINALLY_CLEAN(1); 71| 2.45k| return IGRAPH_SUCCESS; 72| 2.45k|} igraph_trie_destroy: 103| 2.45k|void igraph_trie_destroy(igraph_trie_t *t) { 104| 2.45k| if (t->storekeys) { ------------------ | Branch (104:9): [True: 2.45k, False: 0] ------------------ 105| 2.45k| igraph_strvector_destroy(&t->keys); 106| 2.45k| } 107| 2.45k| igraph_i_trie_destroy_node(&t->node); 108| 2.45k|} igraph_trie_get: 305| 676k|igraph_error_t igraph_trie_get(igraph_trie_t *t, const char *key, igraph_integer_t *id) { 306| 676k| if (!t->storekeys) { ------------------ | Branch (306:9): [True: 0, False: 676k] ------------------ 307| 0| IGRAPH_CHECK(igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 308| 0| if (*id > t->maxvalue) { ------------------ | Branch (308:13): [True: 0, False: 0] ------------------ 309| 0| t->maxvalue = *id; 310| 0| } 311| 676k| } else { 312| 676k| igraph_error_t ret; 313| | 314| 676k| IGRAPH_FINALLY_ENTER(); 315| | /* Add it to the string vector first, we can undo this later */ 316| 676k| ret = igraph_strvector_push_back(&t->keys, key); 317| 676k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (317:13): [True: 0, False: 676k] ------------------ 318| 0| IGRAPH_FINALLY_EXIT(); 319| 0| IGRAPH_ERROR("cannot get element from trie", ret); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 320| 0| } 321| 676k| ret = igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id); 322| 676k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (322:13): [True: 0, False: 676k] ------------------ 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); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 326| 0| } 327| | 328| | /* everything is fine */ 329| 676k| if (*id > t->maxvalue) { ------------------ | Branch (329:13): [True: 42.8k, False: 633k] ------------------ 330| 42.8k| t->maxvalue = *id; 331| 633k| } else { 332| 633k| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */ 333| 633k| } 334| 676k| IGRAPH_FINALLY_EXIT(); 335| 676k| } 336| | 337| 676k| return IGRAPH_SUCCESS; 338| 676k|} igraph_trie_get_len: 358| 128k| igraph_integer_t *id) { 359| | 360| 128k| char *tmp = strndup(key, length); 361| 128k| if (! tmp) { ------------------ | Branch (361:9): [True: 0, False: 128k] ------------------ 362| 0| IGRAPH_ERROR("Cannot get from trie.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 363| 0| } 364| 128k| IGRAPH_FINALLY(igraph_free, tmp); ------------------ | | 695| 128k| do { \ | | 696| 128k| /* the following branch makes the compiler check the compatibility of \ | | 697| 128k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 128k| * incorrect destructor function with the pointer */ \ | | 699| 128k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 128k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 128k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 365| 128k| IGRAPH_CHECK(igraph_trie_get(t, tmp, id)); ------------------ | | 752| 128k| do { \ | | 753| 128k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 128k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 128k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 128k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 128k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 366| 128k| IGRAPH_FREE(tmp); ------------------ | | 35| 128k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 367| 128k| IGRAPH_FINALLY_CLEAN(1); 368| | 369| 128k| return IGRAPH_SUCCESS; 370| 128k|} igraph_trie_size: 416| 778|igraph_integer_t igraph_trie_size(igraph_trie_t *t) { 417| 778| return t->maxvalue + 1; 418| 778|} igraph_i_trie_borrow_keys: 435| 87|const igraph_strvector_t* igraph_i_trie_borrow_keys(igraph_trie_t *t) { 436| 87| return &t->keys; 437| 87|} trie.c:igraph_i_trie_init_node: 41| 2.45k|static igraph_error_t igraph_i_trie_init_node(igraph_trie_node_t *t) { 42| 2.45k| IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0); ------------------ | | 63| 2.45k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 752| 2.45k| do { \ | | | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 64| 2.45k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 695| 2.45k| do { \ | | | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.45k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (64:65): [Folded - Ignored] | | ------------------ ------------------ 43| 2.45k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0); ------------------ | | 51| 2.45k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 752| 2.45k| do { \ | | | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 2.45k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 695| 2.45k| do { \ | | | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.45k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (52:65): [Folded - Ignored] | | ------------------ ------------------ 44| 2.45k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->values, 0); ------------------ | | 124| 2.45k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 2.45k| do { \ | | | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 2.45k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 2.45k| do { \ | | | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.45k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 45| 2.45k| IGRAPH_FINALLY_CLEAN(3); 46| 2.45k| return IGRAPH_SUCCESS; 47| 2.45k|} trie.c:igraph_i_trie_destroy_node: 92| 2.45k|static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) { 93| 2.45k| igraph_i_trie_destroy_node_helper(t, 0); 94| 2.45k|} trie.c:igraph_i_trie_destroy_node_helper: 74| 23.9k|static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) { 75| 23.9k| igraph_integer_t i; 76| 23.9k| igraph_strvector_destroy(&t->strs); 77| 23.9k| igraph_integer_t children_size = igraph_vector_ptr_size(&t->children); 78| 78.1k| for (i = 0; i < children_size; i++) { ------------------ | Branch (78:17): [True: 54.1k, False: 23.9k] ------------------ 79| 54.1k| igraph_trie_node_t *child = VECTOR(t->children)[i]; ------------------ | | 69| 54.1k|#define VECTOR(v) ((v).stor_begin) ------------------ 80| 54.1k| if (child != 0) { ------------------ | Branch (80:13): [True: 21.4k, False: 32.6k] ------------------ 81| 21.4k| igraph_i_trie_destroy_node_helper(child, 1); 82| 21.4k| } 83| 54.1k| } 84| 23.9k| igraph_vector_ptr_destroy(&t->children); 85| 23.9k| igraph_vector_int_destroy(&t->values); 86| 23.9k| if (sfree) { ------------------ | Branch (86:9): [True: 21.4k, False: 2.45k] ------------------ 87| 21.4k| IGRAPH_FREE(t); ------------------ | | 35| 21.4k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 88| 21.4k| } 89| 23.9k|} trie.c:igraph_i_trie_get_node: 130| 2.48M|) { 131| 2.48M| const char *str; 132| 2.48M| igraph_integer_t i; 133| 2.48M| igraph_bool_t add; 134| | 135| | /* If newvalue is negative, we don't add the node if nonexistent, only check 136| | * for its existence */ 137| 2.48M| add = (newvalue >= 0); 138| | 139| 2.48M| igraph_integer_t strs_size = igraph_strvector_size(&t->strs); 140| 9.33M| for (i = 0; i < strs_size; i++) { ------------------ | Branch (140:17): [True: 9.31M, False: 19.7k] ------------------ 141| 9.31M| size_t diff; 142| 9.31M| str = igraph_strvector_get(&t->strs, i); 143| 9.31M| diff = igraph_i_strdiff(str, key); 144| | 145| 9.31M| if (diff == 0) { ------------------ | Branch (145:13): [True: 6.84M, False: 2.46M] ------------------ 146| | 147| | /* ------------------------------------ */ 148| | /* No match, next */ 149| | 150| 6.84M| } else if (str[diff] == '\0' && key[diff] == '\0') { ------------------ | Branch (150:20): [True: 2.44M, False: 18.9k] | Branch (150:41): [True: 634k, False: 1.80M] ------------------ 151| | 152| | /* ------------------------------------ */ 153| | /* They are exactly the same */ 154| 634k| if (VECTOR(t->values)[i] != -1) { ------------------ | | 69| 634k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (154:17): [True: 633k, False: 1.54k] ------------------ 155| 633k| *id = VECTOR(t->values)[i]; ------------------ | | 69| 633k|#define VECTOR(v) ((v).stor_begin) ------------------ 156| 633k| return IGRAPH_SUCCESS; 157| 633k| } else { 158| 1.54k| VECTOR(t->values)[i] = newvalue; ------------------ | | 69| 1.54k|#define VECTOR(v) ((v).stor_begin) ------------------ 159| 1.54k| *id = newvalue; 160| 1.54k| return IGRAPH_SUCCESS; 161| 1.54k| } 162| | 163| 1.82M| } else if (str[diff] == '\0') { ------------------ | Branch (163:20): [True: 1.80M, False: 18.9k] ------------------ 164| | 165| | /* ------------------------------------ */ 166| | /* str is prefix of key, follow its link if there is one */ 167| 1.80M| igraph_trie_node_t *node = VECTOR(t->children)[i]; ------------------ | | 69| 1.80M|#define VECTOR(v) ((v).stor_begin) ------------------ 168| 1.80M| if (node != 0) { ------------------ | Branch (168:17): [True: 1.80M, False: 2.54k] ------------------ 169| 1.80M| return igraph_i_trie_get_node(node, key + diff, newvalue, id); 170| 1.80M| } else if (add) { ------------------ | Branch (170:24): [True: 2.54k, False: 0] ------------------ 171| 2.54k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 32| 2.54k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 172| 2.54k| if (! node) { ------------------ | Branch (172:21): [True: 0, False: 2.54k] ------------------ 173| 0| IGRAPH_ERROR("Cannot add to trie.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 174| 0| } 175| 2.54k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 695| 2.54k| do { \ | | 696| 2.54k| /* the following branch makes the compiler check the compatibility of \ | | 697| 2.54k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 2.54k| * incorrect destructor function with the pointer */ \ | | 699| 2.54k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 2.54k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 2.54k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 176| 2.54k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1); ------------------ | | 63| 2.54k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 752| 2.54k| do { \ | | | | 753| 2.54k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.54k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.54k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.54k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 64| 2.54k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 695| 2.54k| do { \ | | | | 696| 2.54k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.54k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.54k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.54k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.54k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.54k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (64:65): [Folded - Ignored] | | ------------------ ------------------ 177| 2.54k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1); ------------------ | | 51| 2.54k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 752| 2.54k| do { \ | | | | 753| 2.54k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.54k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.54k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.54k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 2.54k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 695| 2.54k| do { \ | | | | 696| 2.54k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.54k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.54k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.54k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.54k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.54k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (52:65): [Folded - Ignored] | | ------------------ ------------------ 178| 2.54k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1); ------------------ | | 124| 2.54k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 2.54k| do { \ | | | | 753| 2.54k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.54k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.54k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.54k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 2.54k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 2.54k| do { \ | | | | 696| 2.54k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.54k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.54k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.54k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.54k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.54k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 179| 2.54k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, key + diff)); ------------------ | | 752| 2.54k| do { \ | | 753| 2.54k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 2.54k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 2.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.54k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 2.54k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 180| 2.54k| IGRAPH_FINALLY_CLEAN(4); 181| | 182| 2.54k| VECTOR(node->children)[0] = 0; ------------------ | | 69| 2.54k|#define VECTOR(v) ((v).stor_begin) ------------------ 183| 2.54k| VECTOR(node->values)[0] = newvalue; ------------------ | | 69| 2.54k|#define VECTOR(v) ((v).stor_begin) ------------------ 184| | 185| 2.54k| VECTOR(t->children)[i] = node; ------------------ | | 69| 2.54k|#define VECTOR(v) ((v).stor_begin) ------------------ 186| | 187| 2.54k| *id = newvalue; 188| 2.54k| return IGRAPH_SUCCESS; 189| 2.54k| } else { 190| 0| *id = -1; 191| 0| return IGRAPH_SUCCESS; 192| 0| } 193| | 194| 1.80M| } else if (key[diff] == '\0' && add) { ------------------ | Branch (194:20): [True: 6.02k, False: 12.9k] | Branch (194:41): [True: 6.02k, False: 0] ------------------ 195| | 196| | /* ------------------------------------ */ 197| | /* key is prefix of str, the node has to be cut */ 198| 6.02k| char *str2; 199| | 200| 6.02k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 32| 6.02k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 201| 6.02k| if (! node) { ------------------ | Branch (201:17): [True: 0, False: 6.02k] ------------------ 202| 0| IGRAPH_ERROR("Cannot add to trie.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 203| 0| } 204| 6.02k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 695| 6.02k| do { \ | | 696| 6.02k| /* the following branch makes the compiler check the compatibility of \ | | 697| 6.02k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 6.02k| * incorrect destructor function with the pointer */ \ | | 699| 6.02k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 6.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 6.02k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 205| 6.02k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1); ------------------ | | 63| 6.02k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 752| 6.02k| do { \ | | | | 753| 6.02k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 6.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 6.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 6.02k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 6.02k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 64| 6.02k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 695| 6.02k| do { \ | | | | 696| 6.02k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 6.02k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 6.02k| * incorrect destructor function with the pointer */ \ | | | | 699| 6.02k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 6.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 6.02k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (64:65): [Folded - Ignored] | | ------------------ ------------------ 206| 6.02k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1); ------------------ | | 51| 6.02k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 752| 6.02k| do { \ | | | | 753| 6.02k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 6.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 6.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 6.02k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 6.02k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 6.02k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 695| 6.02k| do { \ | | | | 696| 6.02k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 6.02k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 6.02k| * incorrect destructor function with the pointer */ \ | | | | 699| 6.02k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 6.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 6.02k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (52:65): [Folded - Ignored] | | ------------------ ------------------ 207| 6.02k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1); ------------------ | | 124| 6.02k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 6.02k| do { \ | | | | 753| 6.02k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 6.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 6.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 6.02k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 6.02k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 6.02k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 6.02k| do { \ | | | | 696| 6.02k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 6.02k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 6.02k| * incorrect destructor function with the pointer */ \ | | | | 699| 6.02k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 6.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 6.02k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 208| 6.02k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 752| 6.02k| do { \ | | 753| 6.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 209| | 210| 6.02k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 69| 6.02k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 69| 6.02k|#define VECTOR(v) ((v).stor_begin) ------------------ 211| 6.02k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 69| 6.02k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 69| 6.02k|#define VECTOR(v) ((v).stor_begin) ------------------ 212| | 213| 6.02k| str2 = strdup(str); 214| 6.02k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 807| 6.02k| do { \ | | 808| 6.02k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 6.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.02k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 6.02k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 215| | 216| 6.02k| str2[diff] = '\0'; 217| 6.02k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 695| 6.02k| do { \ | | 696| 6.02k| /* the following branch makes the compiler check the compatibility of \ | | 697| 6.02k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 6.02k| * incorrect destructor function with the pointer */ \ | | 699| 6.02k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 6.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 6.02k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 218| | 219| 6.02k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 752| 6.02k| do { \ | | 753| 6.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 220| | 221| 6.02k| IGRAPH_FREE(str2); ------------------ | | 35| 6.02k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 222| 6.02k| IGRAPH_FINALLY_CLEAN(5); 223| | 224| 6.02k| VECTOR(t->values)[i] = newvalue; ------------------ | | 69| 6.02k|#define VECTOR(v) ((v).stor_begin) ------------------ 225| 6.02k| VECTOR(t->children)[i] = node; ------------------ | | 69| 6.02k|#define VECTOR(v) ((v).stor_begin) ------------------ 226| | 227| 6.02k| *id = newvalue; 228| 6.02k| return IGRAPH_SUCCESS; 229| | 230| 12.9k| } else if (add) { ------------------ | Branch (230:20): [True: 12.9k, False: 0] ------------------ 231| | 232| | /* ------------------------------------ */ 233| | /* the first diff characters match */ 234| 12.9k| char *str2; 235| | 236| 12.9k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 32| 12.9k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 237| 12.9k| if (! node) { ------------------ | Branch (237:17): [True: 0, False: 12.9k] ------------------ 238| 0| IGRAPH_ERROR("Cannot add to trie.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 239| 0| } 240| 12.9k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 695| 12.9k| do { \ | | 696| 12.9k| /* the following branch makes the compiler check the compatibility of \ | | 697| 12.9k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 12.9k| * incorrect destructor function with the pointer */ \ | | 699| 12.9k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 12.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 12.9k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 241| 12.9k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2); ------------------ | | 63| 12.9k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 752| 12.9k| do { \ | | | | 753| 12.9k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 12.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 12.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 12.9k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 12.9k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 64| 12.9k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 695| 12.9k| do { \ | | | | 696| 12.9k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 12.9k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 12.9k| * incorrect destructor function with the pointer */ \ | | | | 699| 12.9k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 12.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 12.9k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (64:65): [Folded - Ignored] | | ------------------ ------------------ 242| 12.9k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2); ------------------ | | 51| 12.9k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 752| 12.9k| do { \ | | | | 753| 12.9k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 12.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 12.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 12.9k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 12.9k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 12.9k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 695| 12.9k| do { \ | | | | 696| 12.9k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 12.9k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 12.9k| * incorrect destructor function with the pointer */ \ | | | | 699| 12.9k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 12.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 12.9k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (52:65): [Folded - Ignored] | | ------------------ ------------------ 243| 12.9k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 2); ------------------ | | 124| 12.9k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 12.9k| do { \ | | | | 753| 12.9k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 12.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 12.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 12.9k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 12.9k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 12.9k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 12.9k| do { \ | | | | 696| 12.9k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 12.9k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 12.9k| * incorrect destructor function with the pointer */ \ | | | | 699| 12.9k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 12.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 12.9k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 244| 12.9k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 752| 12.9k| do { \ | | 753| 12.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 12.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 12.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 12.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 12.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 245| 12.9k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff)); ------------------ | | 752| 12.9k| do { \ | | 753| 12.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 12.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 12.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 12.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 12.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 246| 12.9k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 69| 12.9k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 69| 12.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 247| 12.9k| VECTOR(node->children)[1] = 0; ------------------ | | 69| 12.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 248| 12.9k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 69| 12.9k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 69| 12.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 249| 12.9k| VECTOR(node->values)[1] = newvalue; ------------------ | | 69| 12.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 250| | 251| 12.9k| str2 = strdup(str); 252| 12.9k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 807| 12.9k| do { \ | | 808| 12.9k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 12.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 12.9k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 12.9k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 253| | 254| 12.9k| str2[diff] = '\0'; 255| 12.9k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 695| 12.9k| do { \ | | 696| 12.9k| /* the following branch makes the compiler check the compatibility of \ | | 697| 12.9k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 12.9k| * incorrect destructor function with the pointer */ \ | | 699| 12.9k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 12.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 12.9k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 256| | 257| 12.9k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 752| 12.9k| do { \ | | 753| 12.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 12.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 12.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 12.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 12.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 258| | 259| 12.9k| IGRAPH_FREE(str2); ------------------ | | 35| 12.9k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 260| 12.9k| IGRAPH_FINALLY_CLEAN(5); 261| | 262| 12.9k| VECTOR(t->values)[i] = -1; ------------------ | | 69| 12.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 263| 12.9k| VECTOR(t->children)[i] = node; ------------------ | | 69| 12.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 264| | 265| 12.9k| *id = newvalue; 266| 12.9k| return IGRAPH_SUCCESS; 267| 12.9k| } else { 268| | 269| | /* ------------------------------------------------- */ 270| | /* No match, but we requested not to add the new key */ 271| 0| *id = -1; 272| 0| return IGRAPH_SUCCESS; 273| 0| } 274| 9.31M| } 275| | 276| | /* ------------------------------------ */ 277| | /* Nothing matches */ 278| | 279| 19.7k| if (add) { ------------------ | Branch (279:9): [True: 19.7k, False: 0] ------------------ 280| | /* Memory saving at the cost of performance may be possible by using the pattern 281| | * CHECK(reserve(vec, size(vec) + 1)); 282| | * push_back(vec, value); 283| | * This was the original pattern used before igraph 0.10. */ 284| 19.7k| IGRAPH_CHECK(igraph_strvector_push_back(&t->strs, key)); ------------------ | | 752| 19.7k| do { \ | | 753| 19.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 19.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 19.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 19.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 19.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 285| 19.7k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t->children, NULL)); ------------------ | | 752| 19.7k| do { \ | | 753| 19.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 19.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 19.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 19.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 19.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 286| 19.7k| IGRAPH_CHECK(igraph_vector_int_push_back(&t->values, newvalue)); ------------------ | | 752| 19.7k| do { \ | | 753| 19.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 19.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 19.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 19.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 19.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 287| 19.7k| *id = newvalue; 288| 19.7k| } else { 289| 0| *id = -1; 290| 0| } 291| | 292| 19.7k| return IGRAPH_SUCCESS; 293| 19.7k|} trie.c:igraph_i_strdiff: 112| 9.31M|static size_t igraph_i_strdiff(const char *str, const char *key) { 113| 9.31M| size_t diff = 0; 114| 13.7M| while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) { ------------------ | Branch (114:12): [True: 13.0M, False: 640k] | Branch (114:33): [True: 11.2M, False: 1.80M] | Branch (114:54): [True: 4.40M, False: 6.86M] ------------------ 115| 4.40M| diff++; 116| 4.40M| } 117| 9.31M| return diff; 118| 9.31M|} igraph_vector_int_pair_order: 139| 936| igraph_vector_int_t* res, igraph_integer_t nodes) { 140| 936| igraph_integer_t edges = igraph_vector_int_size(v); 141| 936| igraph_vector_int_t ptr; 142| 936| igraph_vector_int_t rad; 143| 936| igraph_integer_t i, j; 144| | 145| 936| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 936| do { \ | | 1108| 936| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 936| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 936] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 936| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 146| 936| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 936| do { \ | | 1108| 936| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 936| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 936] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 936| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 147| | 148| 936| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1); ------------------ | | 124| 936| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 936| do { \ | | | | 753| 936| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 936| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 936| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 936] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 936| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 936| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 936| do { \ | | | | 696| 936| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 936| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 936| * incorrect destructor function with the pointer */ \ | | | | 699| 936| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 936| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 936| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 149| 936| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges); ------------------ | | 124| 936| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 936| do { \ | | | | 753| 936| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 936| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 936| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 936] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 936| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 936| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 936| do { \ | | | | 696| 936| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 936| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 936| * incorrect destructor function with the pointer */ \ | | | | 699| 936| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 936| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 936| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 150| 936| IGRAPH_CHECK(igraph_vector_int_resize(res, edges)); ------------------ | | 752| 936| do { \ | | 753| 936| igraph_error_t igraph_i_ret = (expr); \ | | 754| 936| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 936| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 936] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 936| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 151| | 152| 4.76M| for (i = 0; i < edges; i++) { ------------------ | Branch (152:17): [True: 4.76M, False: 936] ------------------ 153| 4.76M| igraph_integer_t radix = VECTOR(*v2)[i]; ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ 154| 4.76M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (154:13): [True: 4.72M, False: 31.6k] ------------------ 155| 4.72M| VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 69| 4.72M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 69| 4.72M|#define VECTOR(v) ((v).stor_begin) ------------------ 156| 4.72M| } 157| 4.76M| VECTOR(ptr)[radix] = i + 1; ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ 158| 4.76M| } 159| | 160| 936| j = 0; 161| 80.7M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (161:17): [True: 80.7M, False: 936] ------------------ 162| 80.7M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 69| 80.7M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (162:13): [True: 31.6k, False: 80.7M] ------------------ 163| 31.6k| igraph_integer_t next = VECTOR(ptr)[i] - 1; ------------------ | | 69| 31.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 164| 31.6k| VECTOR(*res)[j++] = next; ------------------ | | 69| 31.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 165| 4.76M| while (VECTOR(rad)[next] != 0) { ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (165:20): [True: 4.72M, False: 31.6k] ------------------ 166| 4.72M| next = VECTOR(rad)[next] - 1; ------------------ | | 69| 4.72M|#define VECTOR(v) ((v).stor_begin) ------------------ 167| 4.72M| VECTOR(*res)[j++] = next; ------------------ | | 69| 4.72M|#define VECTOR(v) ((v).stor_begin) ------------------ 168| 4.72M| } 169| 31.6k| } 170| 80.7M| } 171| | 172| 936| igraph_vector_int_null(&ptr); 173| 936| igraph_vector_int_null(&rad); 174| | 175| 4.76M| for (i = 0; i < edges; i++) { ------------------ | Branch (175:17): [True: 4.76M, False: 936] ------------------ 176| 4.76M| igraph_integer_t edge = VECTOR(*res)[edges - i - 1]; ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ 177| 4.76M| igraph_integer_t radix = VECTOR(*v)[edge]; ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ 178| 4.76M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (178:13): [True: 4.72M, False: 31.6k] ------------------ 179| 4.72M| VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 69| 4.72M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 69| 4.72M|#define VECTOR(v) ((v).stor_begin) ------------------ 180| 4.72M| } 181| 4.76M| VECTOR(ptr)[radix] = edge + 1; ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ 182| 4.76M| } 183| | 184| 936| j = 0; 185| 80.7M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (185:17): [True: 80.7M, False: 936] ------------------ 186| 80.7M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 69| 80.7M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (186:13): [True: 31.6k, False: 80.7M] ------------------ 187| 31.6k| igraph_integer_t next = VECTOR(ptr)[i] - 1; ------------------ | | 69| 31.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 188| 31.6k| VECTOR(*res)[j++] = next; ------------------ | | 69| 31.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 189| 4.76M| while (VECTOR(rad)[next] != 0) { ------------------ | | 69| 4.76M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (189:20): [True: 4.72M, False: 31.6k] ------------------ 190| 4.72M| next = VECTOR(rad)[next] - 1; ------------------ | | 69| 4.72M|#define VECTOR(v) ((v).stor_begin) ------------------ 191| 4.72M| VECTOR(*res)[j++] = next; ------------------ | | 69| 4.72M|#define VECTOR(v) ((v).stor_begin) ------------------ 192| 4.72M| } 193| 31.6k| } 194| 80.7M| } 195| | 196| 936| igraph_vector_int_destroy(&ptr); 197| 936| igraph_vector_int_destroy(&rad); 198| 936| IGRAPH_FINALLY_CLEAN(2); 199| | 200| 936| return IGRAPH_SUCCESS; 201| 936|} igraph_vector_init: 135| 2.54k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector)* v, igraph_integer_t size) { 136| 2.54k| igraph_integer_t alloc_size; 137| 2.54k| IGRAPH_ASSERT(size >= 0); ------------------ | | 1107| 2.54k| do { \ | | 1108| 2.54k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.54k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.54k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 138| 2.54k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (138:18): [True: 0, False: 2.54k] ------------------ 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.54k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 32| 2.54k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 2.54k, False: 0] | | ------------------ ------------------ 145| 2.54k| if (v->stor_begin == NULL) { ------------------ | Branch (145:9): [True: 0, False: 2.54k] ------------------ 146| 0| IGRAPH_ERROR("Cannot initialize vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 147| 0| } 148| 2.54k| v->stor_end = v->stor_begin + alloc_size; 149| 2.54k| v->end = v->stor_begin + size; 150| | 151| 2.54k| return IGRAPH_SUCCESS; 152| 2.54k|} igraph_vector_destroy: 400| 2.54k|void FUNCTION(igraph_vector, destroy) (TYPE(igraph_vector)* v) { 401| 2.54k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 2.54k| do { \ | | 1108| 2.54k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.54k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.54k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 402| | /* vector_init() will leave stor_begin set to NULL when it fails. 403| | * We handle these cases gracefully. */ 404| 2.54k| if (v->stor_begin != NULL) { ------------------ | Branch (404:9): [True: 2.54k, False: 0] ------------------ 405| 2.54k| IGRAPH_FREE(v->stor_begin); ------------------ | | 35| 2.54k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 406| 2.54k| v->stor_begin = NULL; 407| 2.54k| } 408| 2.54k|} igraph_vector_capacity: 428| 56.7k|igraph_integer_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector)*v) { 429| 56.7k| return v->stor_end - v->stor_begin; 430| 56.7k|} igraph_vector_reserve: 460| 56.7k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector)* v, igraph_integer_t capacity) { 461| 56.7k| igraph_integer_t current_capacity; 462| 56.7k| BASE *tmp; ------------------ | | 34| 56.7k| #define BASE igraph_real_t ------------------ 463| | 464| 56.7k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 56.7k| do { \ | | 1108| 56.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 56.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.7k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 56.7k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 465| 56.7k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 56.7k| do { \ | | 1108| 56.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 56.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.7k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 56.7k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 466| 56.7k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 56.7k| do { \ | | 1108| 56.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 56.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.7k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 56.7k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 467| | 468| 56.7k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 161| 56.7k| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 56.7k|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 56.7k|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 469| | 470| 56.7k| if (capacity <= current_capacity) { ------------------ | Branch (470:9): [True: 55.6k, False: 1.10k] ------------------ 471| 55.6k| return IGRAPH_SUCCESS; 472| 55.6k| } 473| | 474| 1.10k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 34| 1.10k|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 1.10k, False: 0] | | ------------------ ------------------ 475| 1.10k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 807| 1.10k| do { \ | | 808| 1.10k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 1.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.10k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 1.10k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 476| | 477| 1.10k| v->end = tmp + (v->end - v->stor_begin); 478| 1.10k| v->stor_begin = tmp; 479| 1.10k| v->stor_end = v->stor_begin + capacity; 480| | 481| 1.10k| return IGRAPH_SUCCESS; 482| 1.10k|} igraph_vector_size: 513| 63.2k|igraph_integer_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector)* v) { 514| 63.2k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 63.2k| do { \ | | 1108| 63.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 63.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 63.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 63.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 515| 63.2k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 63.2k| do { \ | | 1108| 63.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 63.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 63.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 63.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 516| 63.2k| return v->end - v->stor_begin; 517| 63.2k|} igraph_vector_push_back: 564| 60.5k|igraph_error_t FUNCTION(igraph_vector, push_back) (TYPE(igraph_vector)* v, BASE e) { 565| 60.5k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 60.5k| do { \ | | 1108| 60.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 60.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 60.5k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 60.5k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 566| 60.5k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 60.5k| do { \ | | 1108| 60.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 60.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 60.5k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 60.5k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 567| | 568| 60.5k| if (v->stor_end == v->end) { ------------------ | Branch (568:9): [True: 624, False: 59.9k] ------------------ 569| | /* full, allocate more storage */ 570| 624| igraph_integer_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 161| 624| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 624|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 624|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 571| 624| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 624|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 624|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (571:37): [True: 624, False: 0] ------------------ 572| 624| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 78| 624|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (572:13): [True: 0, False: 624] ------------------ 573| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 574| 0| } 575| 624| if (new_size == 0) { ------------------ | Branch (575:13): [True: 0, False: 624] ------------------ 576| 0| new_size = 1; 577| 0| } 578| 624| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 752| 624| do { \ | | 753| 624| igraph_error_t igraph_i_ret = (expr); \ | | 754| 624| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 624| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 624] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 624| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 579| 624| } 580| | 581| 60.5k| *(v->end) = e; 582| 60.5k| v->end += 1; 583| | 584| 60.5k| return IGRAPH_SUCCESS; 585| 60.5k|} igraph_vector_fill: 757| 95|void FUNCTION(igraph_vector, fill) (TYPE(igraph_vector)* v, BASE e) { 758| 95| BASE *ptr; ------------------ | | 34| 95| #define BASE igraph_real_t ------------------ 759| 95| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 95| do { \ | | 1108| 95| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 95| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 95] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 95| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 760| 95| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 95| do { \ | | 1108| 95| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 95| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 95] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 95| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 761| 95| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (761:31): [True: 0, False: 95] ------------------ 762| 0| *ptr = e; 763| 0| } 764| 95|} igraph_vector_resize: 1258| 56.1k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_integer_t new_size) { 1259| 56.1k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 56.1k| do { \ | | 1108| 56.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 56.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.1k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 56.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1260| 56.1k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 56.1k| do { \ | | 1108| 56.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 56.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.1k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 56.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1261| 56.1k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 752| 56.1k| do { \ | | 753| 56.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 56.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 56.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 56.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1262| 56.1k| v->end = v->stor_begin + new_size; 1263| 56.1k| return IGRAPH_SUCCESS; 1264| 56.1k|} igraph_vector_append: 2462| 95| const TYPE(igraph_vector) *from) { 2463| 95| igraph_integer_t tosize, fromsize; 2464| 95| igraph_integer_t newsize; 2465| | 2466| 95| tosize = FUNCTION(igraph_vector, size)(to); ------------------ | | 161| 95| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 95|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 95|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2467| 95| fromsize = FUNCTION(igraph_vector, size)(from); ------------------ | | 161| 95| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 95|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 95|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2468| 95| IGRAPH_SAFE_ADD(tosize, fromsize, &newsize); ------------------ | | 47| 95| do { \ | | 48| 95| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 95| igraph_integer_t _safe_sum; \ | | 50| 95| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 95] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 95| *(res) = _safe_sum; \ | | 54| 95| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 2469| 95| IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, newsize)); ------------------ | | 752| 95| do { \ | | 753| 95| igraph_error_t igraph_i_ret = (expr); \ | | 754| 95| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 95| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 95] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 95| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2470| 95| memcpy(to->stor_begin + tosize, from->stor_begin, 2471| 95| sizeof(BASE) * fromsize); 2472| 95| to->end = to->stor_begin + tosize + fromsize; 2473| | 2474| 95| return IGRAPH_SUCCESS; 2475| 95|} igraph_vector_int_init: 135| 36.8k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector)* v, igraph_integer_t size) { 136| 36.8k| igraph_integer_t alloc_size; 137| 36.8k| IGRAPH_ASSERT(size >= 0); ------------------ | | 1107| 36.8k| do { \ | | 1108| 36.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 36.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 36.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 36.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 138| 36.8k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (138:18): [True: 24.8k, False: 11.9k] ------------------ 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| 36.8k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 32| 36.8k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 36.8k, False: 0] | | ------------------ ------------------ 145| 36.8k| if (v->stor_begin == NULL) { ------------------ | Branch (145:9): [True: 0, False: 36.8k] ------------------ 146| 0| IGRAPH_ERROR("Cannot initialize vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 147| 0| } 148| 36.8k| v->stor_end = v->stor_begin + alloc_size; 149| 36.8k| v->end = v->stor_begin + size; 150| | 151| 36.8k| return IGRAPH_SUCCESS; 152| 36.8k|} igraph_vector_int_destroy: 400| 36.8k|void FUNCTION(igraph_vector, destroy) (TYPE(igraph_vector)* v) { 401| 36.8k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 36.8k| do { \ | | 1108| 36.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 36.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 36.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 36.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 402| | /* vector_init() will leave stor_begin set to NULL when it fails. 403| | * We handle these cases gracefully. */ 404| 36.8k| if (v->stor_begin != NULL) { ------------------ | Branch (404:9): [True: 36.8k, False: 0] ------------------ 405| 36.8k| IGRAPH_FREE(v->stor_begin); ------------------ | | 35| 36.8k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 406| 36.8k| v->stor_begin = NULL; 407| 36.8k| } 408| 36.8k|} igraph_vector_int_capacity: 428| 21.8k|igraph_integer_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector)*v) { 429| 21.8k| return v->stor_end - v->stor_begin; 430| 21.8k|} igraph_vector_int_reserve: 460| 21.8k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector)* v, igraph_integer_t capacity) { 461| 21.8k| igraph_integer_t current_capacity; 462| 21.8k| BASE *tmp; ------------------ | | 71| 21.8k| #define BASE igraph_integer_t ------------------ 463| | 464| 21.8k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 21.8k| do { \ | | 1108| 21.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 21.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 21.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 21.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 465| 21.8k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 21.8k| do { \ | | 1108| 21.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 21.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 21.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 21.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 466| 21.8k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 21.8k| do { \ | | 1108| 21.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 21.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 21.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 21.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 467| | 468| 21.8k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 169| 21.8k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 21.8k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 21.8k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 469| | 470| 21.8k| if (capacity <= current_capacity) { ------------------ | Branch (470:9): [True: 7.57k, False: 14.2k] ------------------ 471| 7.57k| return IGRAPH_SUCCESS; 472| 7.57k| } 473| | 474| 14.2k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 34| 14.2k|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 14.2k, False: 0] | | ------------------ ------------------ 475| 14.2k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 807| 14.2k| do { \ | | 808| 14.2k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.2k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 14.2k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 476| | 477| 14.2k| v->end = tmp + (v->end - v->stor_begin); 478| 14.2k| v->stor_begin = tmp; 479| 14.2k| v->stor_end = v->stor_begin + capacity; 480| | 481| 14.2k| return IGRAPH_SUCCESS; 482| 14.2k|} igraph_vector_int_size: 513| 84.8k|igraph_integer_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector)* v) { 514| 84.8k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 84.8k| do { \ | | 1108| 84.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 84.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 84.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 84.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 515| 84.8k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 84.8k| do { \ | | 1108| 84.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 84.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 84.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 84.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 516| 84.8k| return v->end - v->stor_begin; 517| 84.8k|} igraph_vector_int_push_back: 564| 13.6M|igraph_error_t FUNCTION(igraph_vector, push_back) (TYPE(igraph_vector)* v, BASE e) { 565| 13.6M| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 13.6M| do { \ | | 1108| 13.6M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 13.6M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.6M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 13.6M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 566| 13.6M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 13.6M| do { \ | | 1108| 13.6M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 13.6M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.6M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 13.6M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 567| | 568| 13.6M| if (v->stor_end == v->end) { ------------------ | Branch (568:9): [True: 11.5k, False: 13.6M] ------------------ 569| | /* full, allocate more storage */ 570| 11.5k| igraph_integer_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 169| 11.5k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 11.5k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 11.5k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 571| 11.5k| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 11.5k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 11.5k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (571:37): [True: 11.5k, False: 0] ------------------ 572| 11.5k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 78| 11.5k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (572:13): [True: 0, False: 11.5k] ------------------ 573| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 574| 0| } 575| 11.5k| if (new_size == 0) { ------------------ | Branch (575:13): [True: 0, False: 11.5k] ------------------ 576| 0| new_size = 1; 577| 0| } 578| 11.5k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 752| 11.5k| do { \ | | 753| 11.5k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 11.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 11.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.5k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 11.5k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 579| 11.5k| } 580| | 581| 13.6M| *(v->end) = e; 582| 13.6M| v->end += 1; 583| | 584| 13.6M| return IGRAPH_SUCCESS; 585| 13.6M|} igraph_vector_int_null: 737| 2.18k|void FUNCTION(igraph_vector, null) (TYPE(igraph_vector)* v) { 738| 2.18k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 2.18k| do { \ | | 1108| 2.18k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.18k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.18k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.18k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 739| 2.18k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 2.18k| do { \ | | 1108| 2.18k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.18k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.18k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.18k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 740| 2.18k| if (FUNCTION(igraph_vector, size)(v) > 0) { ------------------ | | 169| 2.18k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 2.18k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 2.18k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ | Branch (740:9): [True: 1.87k, False: 316] ------------------ 741| 1.87k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v)); ------------------ | | 169| 1.87k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 1.87k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 1.87k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 742| 1.87k| } 743| 2.18k|} igraph_vector_int_resize: 1258| 5.72k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_integer_t new_size) { 1259| 5.72k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 5.72k| do { \ | | 1108| 5.72k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 5.72k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.72k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 5.72k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1260| 5.72k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 5.72k| do { \ | | 1108| 5.72k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 5.72k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.72k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 5.72k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1261| 5.72k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 752| 5.72k| do { \ | | 753| 5.72k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.72k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.72k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.72k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.72k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1262| 5.72k| v->end = v->stor_begin + new_size; 1263| 5.72k| return IGRAPH_SUCCESS; 1264| 5.72k|} igraph_vector_int_max: 1322| 654|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector)* v) { 1323| 654| BASE max; ------------------ | | 71| 654| #define BASE igraph_integer_t ------------------ 1324| 654| BASE *ptr; ------------------ | | 71| 654| #define BASE igraph_integer_t ------------------ 1325| 654| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 654| do { \ | | 1108| 654| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 654| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 654] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 654| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1326| 654| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 654| do { \ | | 1108| 654| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 654| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 654] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 654| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1327| 654| IGRAPH_ASSERT(v->stor_begin != v->end); ------------------ | | 1107| 654| do { \ | | 1108| 654| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 654| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 654] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 654| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1328| 654| max = *(v->stor_begin); 1329| |#if defined(BASE_IGRAPH_REAL) 1330| | if (isnan(max)) { return max; }; /* Result is NaN */ 1331| |#endif 1332| 654| ptr = v->stor_begin + 1; 1333| 7.48M| while (ptr < v->end) { ------------------ | Branch (1333:12): [True: 7.48M, False: 654] ------------------ 1334| 7.48M| if ((*ptr) > max) { ------------------ | Branch (1334:13): [True: 27.5k, False: 7.45M] ------------------ 1335| 27.5k| max = *ptr; 1336| 27.5k| } 1337| |#if defined(BASE_IGRAPH_REAL) 1338| | else if (isnan(*ptr)) 1339| | return *ptr; /* Result is NaN */ 1340| |#endif 1341| 7.48M| ptr++; 1342| 7.48M| } 1343| 654| return max; 1344| 654|} igraph_vector_int_isininterval: 1893| 748| BASE high) { 1894| 748| BASE *ptr; ------------------ | | 71| 748| #define BASE igraph_integer_t ------------------ 1895| 748| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 748| do { \ | | 1108| 748| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 748| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 748] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 748| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1896| 748| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 748| do { \ | | 1108| 748| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 748| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 748] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 748| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1897| 5.50M| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (1897:31): [True: 5.50M, False: 468] ------------------ 1898| | /* Note that the following is not equivalent to *ptr < low || *ptr > high 1899| | * when *ptr is NaN! */ 1900| 5.50M| if (!(*ptr >= low && *ptr <= high)) { ------------------ | Branch (1900:15): [True: 5.50M, False: 0] | Branch (1900:30): [True: 5.50M, False: 280] ------------------ 1901| 280| return 0; 1902| 280| } 1903| 5.50M| } 1904| 468| return 1; 1905| 748|} igraph_vector_ptr_init: 85| 27.0k|igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_integer_t size) { 86| 27.0k| igraph_integer_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (86:35): [True: 21.9k, False: 5.12k] ------------------ 87| 27.0k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 27.0k| do { \ | | 1108| 27.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 27.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 27.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 27.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 88| 27.0k| if (size < 0) { ------------------ | Branch (88:9): [True: 0, False: 27.0k] ------------------ 89| 0| size = 0; 90| 0| } 91| 27.0k| v->stor_begin = IGRAPH_CALLOC(alloc_size, void*); ------------------ | | 32| 27.0k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 27.0k, False: 0] | | ------------------ ------------------ 92| 27.0k| if (v->stor_begin == 0) { ------------------ | Branch (92:9): [True: 0, False: 27.0k] ------------------ 93| 0| IGRAPH_ERROR("vector ptr init failed", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 94| 0| } 95| 27.0k| v->stor_end = v->stor_begin + alloc_size; 96| 27.0k| v->end = v->stor_begin + size; 97| 27.0k| v->item_destructor = 0; 98| | 99| 27.0k| return IGRAPH_SUCCESS; 100| 27.0k|} igraph_vector_ptr_destroy: 131| 27.0k|void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) { 132| 27.0k| IGRAPH_ASSERT(v != 0); ------------------ | | 1107| 27.0k| do { \ | | 1108| 27.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 27.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 27.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 27.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 133| 27.0k| if (v->stor_begin != 0) { ------------------ | Branch (133:9): [True: 27.0k, False: 0] ------------------ 134| 27.0k| IGRAPH_FREE(v->stor_begin); ------------------ | | 35| 27.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 135| 27.0k| v->stor_begin = NULL; 136| 27.0k| } 137| 27.0k|} igraph_vector_ptr_reserve: 214| 7.03k|igraph_error_t igraph_vector_ptr_reserve(igraph_vector_ptr_t* v, igraph_integer_t capacity) { 215| 7.03k| igraph_integer_t actual_size = igraph_vector_ptr_size(v); 216| 7.03k| void **tmp; 217| 7.03k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 7.03k| do { \ | | 1108| 7.03k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 7.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 7.03k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 7.03k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 218| 7.03k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 7.03k| do { \ | | 1108| 7.03k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 7.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 7.03k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 7.03k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 219| 7.03k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 7.03k| do { \ | | 1108| 7.03k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 7.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 7.03k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 7.03k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 220| | 221| 7.03k| if (capacity <= igraph_vector_ptr_size(v)) { ------------------ | Branch (221:9): [True: 0, False: 7.03k] ------------------ 222| 0| return IGRAPH_SUCCESS; 223| 0| } 224| | 225| 7.03k| tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) capacity, void*); ------------------ | | 34| 7.03k|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 7.03k, False: 0] | | ------------------ ------------------ 226| 7.03k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for pointer vector."); ------------------ | | 807| 7.03k| do { \ | | 808| 7.03k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 7.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 7.03k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 7.03k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 227| | 228| 7.03k| v->stor_begin = tmp; 229| 7.03k| v->stor_end = v->stor_begin + capacity; 230| 7.03k| v->end = v->stor_begin + actual_size; 231| | 232| 7.03k| return IGRAPH_SUCCESS; 233| 7.03k|} igraph_vector_ptr_size: 257| 51.2k|igraph_integer_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v) { 258| 51.2k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 51.2k| do { \ | | 1108| 51.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 51.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 51.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 51.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 259| | /* IGRAPH_ASSERT(v->stor_begin != NULL); */ /* TODO */ 260| 51.2k| return v->end - v->stor_begin; 261| 51.2k|} igraph_vector_ptr_push_back: 309| 20.0k|igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) { 310| 20.0k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 20.0k| do { \ | | 1108| 20.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 20.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 20.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 20.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 311| 20.0k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 20.0k| do { \ | | 1108| 20.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 20.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 20.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 20.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 312| | 313| | /* full, allocate more storage */ 314| 20.0k| if (v->stor_end == v->end) { ------------------ | Branch (314:9): [True: 7.03k, False: 13.0k] ------------------ 315| 7.03k| igraph_integer_t new_size = igraph_vector_ptr_size(v) * 2; 316| 7.03k| if (new_size == 0) { ------------------ | Branch (316:13): [True: 0, False: 7.03k] ------------------ 317| 0| new_size = 1; 318| 0| } 319| 7.03k| IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size)); ------------------ | | 752| 7.03k| do { \ | | 753| 7.03k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 7.03k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 7.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 7.03k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 7.03k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 320| 7.03k| } 321| | 322| 20.0k| *(v->end) = e; 323| 20.0k| v->end += 1; 324| | 325| 20.0k| return IGRAPH_SUCCESS; 326| 20.0k|} igraph_i_attribute_init: 37| 892|igraph_error_t igraph_i_attribute_init(igraph_t *graph, void *attr) { 38| 892| graph->attr = 0; 39| 892| if (igraph_i_attribute_table) { ------------------ | Branch (39:9): [True: 892, False: 0] ------------------ 40| 892| return igraph_i_attribute_table->init(graph, attr); 41| 892| } else { 42| 0| return IGRAPH_SUCCESS; 43| 0| } 44| 892|} igraph_i_attribute_destroy: 46| 892|void igraph_i_attribute_destroy(igraph_t *graph) { 47| 892| if (igraph_i_attribute_table) { ------------------ | Branch (47:9): [True: 892, False: 0] ------------------ 48| 892| igraph_i_attribute_table->destroy(graph); 49| 892| } 50| 892|} igraph_i_attribute_add_vertices: 61| 1.78k|igraph_error_t igraph_i_attribute_add_vertices(igraph_t *graph, igraph_integer_t nv, void *attr) { 62| 1.78k| if (igraph_i_attribute_table) { ------------------ | Branch (62:9): [True: 1.78k, False: 0] ------------------ 63| 1.78k| return igraph_i_attribute_table->add_vertices(graph, nv, attr); 64| 1.78k| } else { 65| 0| return IGRAPH_SUCCESS; 66| 0| } 67| 1.78k|} igraph_i_attribute_add_edges: 100| 468| const igraph_vector_int_t *edges, void *attr) { 101| 468| if (igraph_i_attribute_table) { ------------------ | Branch (101:9): [True: 468, False: 0] ------------------ 102| 468| return igraph_i_attribute_table->add_edges(graph, edges, attr); 103| 468| } else { 104| 0| return IGRAPH_SUCCESS; 105| 0| } 106| 468|} igraph_set_attribute_table: 296| 2.45k|igraph_set_attribute_table(const igraph_attribute_table_t * table) { 297| 2.45k| igraph_attribute_table_t *old = igraph_i_attribute_table; 298| 2.45k| igraph_i_attribute_table = (igraph_attribute_table_t*) table; 299| 2.45k| return old; 300| 2.45k|} igraph_i_property_cache_init: 30| 892|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) { 31| 892| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32); ------------------ | | 64| 892|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)])) ------------------ 32| | 33| 892| memset(cache->value, 0, sizeof(cache->value) / sizeof(cache->value[0])); 34| 892| cache->known = 0; 35| 892| return IGRAPH_SUCCESS; 36| 892|} igraph_i_property_cache_destroy: 51| 892|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) { 52| 892| IGRAPH_UNUSED(cache); ------------------ | | 12| 892|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 53| | /* Nothing to do */ 54| 892|} igraph_i_property_cache_invalidate_conditionally: 151| 2.10k|) { 152| 2.10k| uint32_t invalidate = ~keep_always; 153| 2.10k| uint32_t mask; 154| 2.10k| uint32_t maybe_keep; 155| 2.10k| igraph_bool_t cached_value; 156| | 157| 2.10k| assert(graph->cache != NULL); 158| | 159| | /* The bits of maybe_keep are set to 1 for those properties that are: 160| | * 161| | * - currently cached 162| | * - should _probably_ be invalidated 163| | * - _but_ the current cached value of the property may change the decision 164| | */ 165| 2.10k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true); 166| | 167| 2.10k| if (maybe_keep) { ------------------ | Branch (167:9): [True: 0, False: 2.10k] ------------------ 168| 0| for (igraph_cached_property_t prop = (igraph_cached_property_t ) 0; prop < IGRAPH_PROP_I_SIZE; ++prop) { ------------------ | Branch (168:77): [True: 0, False: 0] ------------------ 169| 0| mask = 1 << prop; 170| 0| if (maybe_keep & mask) { ------------------ | Branch (170:17): [True: 0, False: 0] ------------------ 171| | /* if we get here, we know that the property is cached; we have 172| | * masked maybe_keep with graph->cache->known */ 173| 0| cached_value = igraph_i_property_cache_get_bool(graph, prop); 174| 0| if ( 175| 0| ((keep_when_false & mask) && !cached_value) || ------------------ | Branch (175:22): [True: 0, False: 0] | Branch (175:50): [True: 0, False: 0] ------------------ 176| 0| ((keep_when_true & mask) && cached_value) ------------------ | Branch (176:22): [True: 0, False: 0] | Branch (176:49): [True: 0, False: 0] ------------------ 177| 0| ) { 178| 0| invalidate &= ~mask; 179| 0| } 180| 0| } 181| 0| } 182| 0| } 183| | 184| 2.10k| graph->cache->known &= ~invalidate; 185| 2.10k|} cattributes.c:igraph_i_cattribute_init: 169| 892|static igraph_error_t igraph_i_cattribute_init(igraph_t *graph, igraph_vector_ptr_t *attr) { 170| 892| igraph_attribute_record_t *attr_rec; 171| 892| igraph_integer_t i, n; 172| 892| igraph_i_cattributes_t *nattr; 173| | 174| 892| n = attr ? igraph_vector_ptr_size(attr) : 0; ------------------ | Branch (174:9): [True: 0, False: 892] ------------------ 175| | 176| 892| nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t); ------------------ | | 32| 892|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 177| 892| if (!nattr) { ------------------ | Branch (177:9): [True: 0, False: 892] ------------------ 178| 0| IGRAPH_ERROR("Can't init attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 179| 0| } 180| 892| IGRAPH_FINALLY(igraph_free, nattr); ------------------ | | 695| 892| do { \ | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 892| * incorrect destructor function with the pointer */ \ | | 699| 892| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 892| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 181| | 182| 892| IGRAPH_CHECK(igraph_vector_ptr_init(&nattr->gal, n)); ------------------ | | 752| 892| do { \ | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 892] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 892| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 183| 892| IGRAPH_FINALLY(igraph_i_attribute_list_destroy, &nattr->gal); ------------------ | | 695| 892| do { \ | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 892| * incorrect destructor function with the pointer */ \ | | 699| 892| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 892| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 184| 892| IGRAPH_CHECK(igraph_vector_ptr_init(&nattr->val, 0)); ------------------ | | 752| 892| do { \ | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 892] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 892| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 185| 892| IGRAPH_FINALLY(igraph_vector_ptr_destroy, &nattr->val); ------------------ | | 695| 892| do { \ | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 892| * incorrect destructor function with the pointer */ \ | | 699| 892| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 892| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 186| 892| IGRAPH_CHECK(igraph_vector_ptr_init(&nattr->eal, 0)); ------------------ | | 752| 892| do { \ | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 892] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 892| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 187| 892| IGRAPH_FINALLY(igraph_vector_ptr_destroy, &nattr->eal); ------------------ | | 695| 892| do { \ | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 892| * incorrect destructor function with the pointer */ \ | | 699| 892| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 892| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 188| | 189| 892| for (i = 0; i < n; i++) { ------------------ | Branch (189:17): [True: 0, False: 892] ------------------ 190| 0| IGRAPH_CHECK(igraph_i_cattributes_copy_attribute_record( ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 191| 0| &attr_rec, VECTOR(*attr)[i])); 192| 0| VECTOR(nattr->gal)[i] = attr_rec; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 193| 0| } 194| | 195| 892| graph->attr = nattr; 196| 892| IGRAPH_FINALLY_CLEAN(4); 197| | 198| 892| return IGRAPH_SUCCESS; 199| 892|} cattributes.c:igraph_i_attribute_list_destroy: 143| 2.67k|static void igraph_i_attribute_list_destroy(igraph_vector_ptr_t *attrlist) { 144| 2.67k| igraph_integer_t i; 145| 2.67k| igraph_integer_t n = igraph_vector_ptr_size(attrlist); 146| 2.97k| for (i = 0; i < n; i++) { ------------------ | Branch (146:17): [True: 296, False: 2.67k] ------------------ 147| 296| igraph_attribute_record_t *rec = VECTOR(*attrlist)[i]; ------------------ | | 69| 296|#define VECTOR(v) ((v).stor_begin) ------------------ 148| 296| if (rec) { ------------------ | Branch (148:13): [True: 296, False: 0] ------------------ 149| 296| if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (149:17): [True: 95, False: 201] ------------------ 150| 95| igraph_vector_t *num = (igraph_vector_t *) rec->value; 151| 95| igraph_vector_destroy(num); 152| 95| IGRAPH_FREE(num); ------------------ | | 35| 95|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 153| 201| } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) { ------------------ | Branch (153:24): [True: 201, False: 0] ------------------ 154| 201| igraph_strvector_t *str = (igraph_strvector_t *) rec->value; 155| 201| igraph_strvector_destroy(str); 156| 201| IGRAPH_FREE(str); ------------------ | | 35| 201|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 157| 201| } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) { ------------------ | Branch (157:24): [True: 0, False: 0] ------------------ 158| 0| igraph_vector_bool_t *boolvec = (igraph_vector_bool_t *) rec->value; 159| 0| igraph_vector_bool_destroy(boolvec); 160| 0| IGRAPH_FREE(boolvec); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 161| 0| } 162| 296| IGRAPH_FREE(rec->name); ------------------ | | 35| 296|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 163| 296| IGRAPH_FREE(rec); ------------------ | | 35| 296|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 164| 296| } 165| 296| } 166| 2.67k| igraph_vector_ptr_destroy(attrlist); 167| 2.67k|} cattributes.c:igraph_i_cattribute_destroy: 201| 892|static void igraph_i_cattribute_destroy(igraph_t *graph) { 202| 892| igraph_i_cattributes_t *attr = graph->attr; 203| 892| igraph_vector_ptr_t *als[3] = { &attr->gal, &attr->val, &attr->eal }; 204| 3.56k| for (size_t a = 0; a < 3; a++) { ------------------ | Branch (204:24): [True: 2.67k, False: 892] ------------------ 205| 2.67k| igraph_i_attribute_list_destroy(als[a]); 206| 2.67k| } 207| 892| IGRAPH_FREE(graph->attr); /* sets to NULL */ ------------------ | | 35| 892|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 208| 892|} cattributes.c:igraph_i_cattribute_add_vertices: 449| 1.78k| igraph_vector_ptr_t *nattr) { 450| | /* Record information needed to restore attribute vector sizes */ 451| 1.78k| igraph_i_cattributes_t *attr = graph->attr; 452| 1.78k| igraph_vector_ptr_t *val = &attr->val; 453| 1.78k| igraph_integer_t origlen = igraph_vcount(graph) - nv; 454| | 455| | /* Attempt adding attributes */ 456| 1.78k| igraph_error_t err = igraph_i_cattribute_add_vertices_inner(graph, nv, nattr); 457| 1.78k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (457:9): [True: 144, False: 1.64k] ------------------ 458| | /* If unsuccessful, revert attribute vector sizes. 459| | * The following function assumes that all attributes vectors that 460| | * are present have a length at least as great as origlen. 461| | * This is true at the moment because any new attributes that are 462| | * added to the graph are created directly at 'origlen' instead of 463| | * being created at smaller sizes and resized later. 464| | * 465| | * NOTE: While this ensures that all attribute vector lengths are 466| | * correct, it does not ensure that no extra attributes have 467| | * been added to the graph. However, the presence of extra 468| | * attributes does not make the attribute table inconsistent 469| | * like the incorrect attribute vector lengths would. 470| | */ 471| 144| igraph_i_cattribute_revert_attribute_vector_sizes(val, origlen); 472| 144| } 473| 1.78k| return err; 474| 1.78k|} cattributes.c:igraph_i_cattribute_add_vertices_inner: 287| 1.78k| igraph_vector_ptr_t *nattr) { 288| | 289| 1.78k| igraph_i_cattributes_t *attr = graph->attr; 290| 1.78k| igraph_vector_ptr_t *val = &attr->val; 291| 1.78k| igraph_integer_t length = igraph_vector_ptr_size(val); 292| 1.78k| igraph_integer_t nattrno = nattr == NULL ? 0 : igraph_vector_ptr_size(nattr); ------------------ | Branch (292:32): [True: 1.58k, False: 201] ------------------ 293| 1.78k| igraph_integer_t origlen = igraph_vcount(graph) - nv; 294| 1.78k| igraph_integer_t newattrs = 0, i; 295| 1.78k| igraph_vector_int_t news; 296| | 297| | /* First add the new attributes if any */ 298| 1.78k| newattrs = 0; 299| 1.78k| IGRAPH_VECTOR_INT_INIT_FINALLY(&news, 0); ------------------ | | 124| 1.78k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 1.78k| do { \ | | | | 753| 1.78k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 1.78k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 1.78k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 1.78k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 1.78k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 1.78k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 1.78k| do { \ | | | | 696| 1.78k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 1.78k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 1.78k| * incorrect destructor function with the pointer */ \ | | | | 699| 1.78k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 1.78k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 1.78k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 300| 1.98k| for (i = 0; i < nattrno; i++) { ------------------ | Branch (300:17): [True: 201, False: 1.78k] ------------------ 301| 201| igraph_attribute_record_t *nattr_entry = VECTOR(*nattr)[i]; ------------------ | | 69| 201|#define VECTOR(v) ((v).stor_begin) ------------------ 302| 201| const char *nname = nattr_entry->name; 303| 201| igraph_integer_t j; 304| 201| igraph_bool_t l = igraph_i_cattribute_find(val, nname, &j); 305| 201| if (!l) { ------------------ | Branch (305:13): [True: 201, False: 0] ------------------ 306| 201| newattrs++; 307| 201| IGRAPH_CHECK(igraph_vector_int_push_back(&news, i)); ------------------ | | 752| 201| do { \ | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 201] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 201| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 308| 201| } else { 309| | /* check types */ 310| 0| if (nattr_entry->type != ------------------ | Branch (310:17): [True: 0, False: 0] ------------------ 311| 0| ((igraph_attribute_record_t*)VECTOR(*val)[j])->type) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 312| 0| IGRAPH_ERROR("You cannot mix attribute types", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 313| 0| } 314| 0| } 315| 201| } 316| | 317| | /* Add NA/empty string vectors for the existing vertices */ 318| 1.78k| if (newattrs != 0) { ------------------ | Branch (318:9): [True: 201, False: 1.58k] ------------------ 319| 402| for (i = 0; i < newattrs; i++) { ------------------ | Branch (319:21): [True: 201, False: 201] ------------------ 320| 201| igraph_attribute_record_t *tmp = VECTOR(*nattr)[VECTOR(news)[i]]; ------------------ | | 69| 201|#define VECTOR(v) ((v).stor_begin) ------------------ igraph_attribute_record_t *tmp = VECTOR(*nattr)[VECTOR(news)[i]]; ------------------ | | 69| 201|#define VECTOR(v) ((v).stor_begin) ------------------ 321| 201| igraph_attribute_record_t *newrec = IGRAPH_CALLOC(1, igraph_attribute_record_t); ------------------ | | 32| 201|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 322| 201| igraph_attribute_type_t type = tmp->type; 323| 201| if (!newrec) { ------------------ | Branch (323:17): [True: 0, False: 201] ------------------ 324| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 325| 0| } 326| 201| IGRAPH_FINALLY(igraph_free, newrec); ------------------ | | 695| 201| do { \ | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 201| * incorrect destructor function with the pointer */ \ | | 699| 201| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 201| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 327| 201| newrec->type = type; 328| 201| newrec->name = strdup(tmp->name); 329| 201| if (!newrec->name) { ------------------ | Branch (329:17): [True: 0, False: 201] ------------------ 330| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 331| 0| } 332| 201| IGRAPH_FINALLY(igraph_free, (char*)newrec->name); ------------------ | | 695| 201| do { \ | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 201| * incorrect destructor function with the pointer */ \ | | 699| 201| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 201| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 333| 201| if (type == IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (333:17): [True: 0, False: 201] ------------------ 334| 0| igraph_vector_t *newnum = IGRAPH_CALLOC(1, igraph_vector_t); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 335| 0| if (!newnum) { ------------------ | Branch (335:21): [True: 0, False: 0] ------------------ 336| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 337| 0| } 338| 0| IGRAPH_FINALLY(igraph_free, newnum); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 339| 0| IGRAPH_VECTOR_INIT_FINALLY(newnum, origlen); ------------------ | | 109| 0| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 0| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 340| 0| newrec->value = newnum; 341| 0| igraph_vector_fill(newnum, IGRAPH_NAN); ------------------ | | 153| 0|#define IGRAPH_NAN ((double)NAN) ------------------ 342| 201| } else if (type == IGRAPH_ATTRIBUTE_STRING) { ------------------ | Branch (342:24): [True: 201, False: 0] ------------------ 343| 201| igraph_strvector_t *newstr = IGRAPH_CALLOC(1, igraph_strvector_t); ------------------ | | 32| 201|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 344| 201| if (!newstr) { ------------------ | Branch (344:21): [True: 0, False: 201] ------------------ 345| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 346| 0| } 347| 201| IGRAPH_FINALLY(igraph_free, newstr); ------------------ | | 695| 201| do { \ | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 201| * incorrect destructor function with the pointer */ \ | | 699| 201| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 201| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 348| 201| IGRAPH_STRVECTOR_INIT_FINALLY(newstr, origlen); ------------------ | | 63| 201| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 64| 201| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (64:65): [Folded - Ignored] | | ------------------ ------------------ 349| 201| newrec->value = newstr; 350| 201| } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) { ------------------ | Branch (350:24): [True: 0, False: 0] ------------------ 351| 0| igraph_vector_bool_t *newbool = IGRAPH_CALLOC(1, igraph_vector_bool_t); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 352| 0| if (!newbool) { ------------------ | Branch (352:21): [True: 0, False: 0] ------------------ 353| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 354| 0| } 355| 0| IGRAPH_FINALLY(igraph_free, newbool); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 356| 0| IGRAPH_VECTOR_BOOL_INIT_FINALLY(newbool, origlen); ------------------ | | 114| 0| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 115| 0| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (115:65): [Folded - Ignored] | | ------------------ ------------------ 357| 0| newrec->value = newbool; 358| 0| igraph_vector_bool_fill(newbool, false); 359| 0| } 360| 201| IGRAPH_CHECK(igraph_vector_ptr_push_back(val, newrec)); ------------------ | | 752| 201| do { \ | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 201] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 201| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 361| 201| IGRAPH_FINALLY_CLEAN(4); 362| 201| } 363| 201| length = igraph_vector_ptr_size(val); 364| 201| } 365| | 366| | /* Now append the new values */ 367| 1.84k| for (i = 0; i < length; i++) { ------------------ | Branch (367:17): [True: 201, False: 1.64k] ------------------ 368| 201| igraph_attribute_record_t *oldrec = VECTOR(*val)[i]; ------------------ | | 69| 201|#define VECTOR(v) ((v).stor_begin) ------------------ 369| 201| igraph_attribute_record_t *newrec = 0; 370| 201| const char *name = oldrec->name; 371| 201| igraph_integer_t j = -1; 372| 201| igraph_bool_t l = false; 373| 201| if (nattr) { ------------------ | Branch (373:13): [True: 201, False: 0] ------------------ 374| 201| l = igraph_i_cattribute_find(nattr, name, &j); 375| 201| } 376| 201| if (l) { ------------------ | Branch (376:13): [True: 201, False: 0] ------------------ 377| | /* This attribute is present in nattr */ 378| 201| igraph_vector_t *oldnum, *newnum; 379| 201| igraph_strvector_t *oldstr, *newstr; 380| 201| igraph_vector_bool_t *oldbool, *newbool; 381| 201| newrec = VECTOR(*nattr)[j]; ------------------ | | 69| 201|#define VECTOR(v) ((v).stor_begin) ------------------ 382| 201| oldnum = (igraph_vector_t*)oldrec->value; 383| 201| newnum = (igraph_vector_t*)newrec->value; 384| 201| oldstr = (igraph_strvector_t*)oldrec->value; 385| 201| newstr = (igraph_strvector_t*)newrec->value; 386| 201| oldbool = (igraph_vector_bool_t*)oldrec->value; 387| 201| newbool = (igraph_vector_bool_t*)newrec->value; 388| 201| if (oldrec->type != newrec->type) { ------------------ | Branch (388:17): [True: 0, False: 201] ------------------ 389| 0| IGRAPH_ERROR("Attribute types do not match.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 390| 0| } 391| 201| switch (oldrec->type) { 392| 0| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (392:13): [True: 0, False: 201] ------------------ 393| 0| if (nv != igraph_vector_size(newnum)) { ------------------ | Branch (393:21): [True: 0, False: 0] ------------------ 394| 0| IGRAPH_ERROR("Invalid numeric attribute length.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 395| 0| } 396| 0| IGRAPH_CHECK(igraph_vector_append(oldnum, newnum)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 397| 0| break; 398| 201| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (398:13): [True: 201, False: 0] ------------------ 399| 201| if (nv != igraph_strvector_size(newstr)) { ------------------ | Branch (399:21): [True: 144, False: 57] ------------------ 400| 144| IGRAPH_ERROR("Invalid string attribute length.", IGRAPH_EINVAL); ------------------ | | 493| 144| do { \ | | 494| 144| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 144| return igraph_errno ; \ | | 496| 144| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 401| 144| } 402| 57| IGRAPH_CHECK(igraph_strvector_append(oldstr, newstr)); ------------------ | | 752| 57| do { \ | | 753| 57| igraph_error_t igraph_i_ret = (expr); \ | | 754| 57| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 57| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 57] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 57| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 403| 57| break; 404| 57| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (404:13): [True: 0, False: 201] ------------------ 405| 0| if (nv != igraph_vector_bool_size(newbool)) { ------------------ | Branch (405:21): [True: 0, False: 0] ------------------ 406| 0| IGRAPH_ERROR("Invalid boolean attribute length.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 407| 0| } 408| 0| IGRAPH_CHECK(igraph_vector_bool_append(oldbool, newbool)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 409| 0| break; 410| 0| default: ------------------ | Branch (410:13): [True: 0, False: 201] ------------------ 411| 0| IGRAPH_WARNING("Invalid attribute type."); ------------------ | | 939| 0| do { \ | | 940| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 941| 0| } while (0) | | ------------------ | | | Branch (941:14): [Folded - Ignored] | | ------------------ ------------------ 412| 0| break; 413| 201| } 414| 201| } else { 415| | /* No such attribute, append NA's */ 416| 0| igraph_vector_t *oldnum = (igraph_vector_t *)oldrec->value; 417| 0| igraph_strvector_t *oldstr = (igraph_strvector_t*)oldrec->value; 418| 0| igraph_vector_bool_t *oldbool = (igraph_vector_bool_t*)oldrec->value; 419| 0| switch (oldrec->type) { 420| 0| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (420:13): [True: 0, False: 0] ------------------ 421| 0| IGRAPH_CHECK(igraph_vector_resize(oldnum, origlen + nv)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 422| 0| for (j = origlen; j < origlen + nv; j++) { ------------------ | Branch (422:35): [True: 0, False: 0] ------------------ 423| 0| VECTOR(*oldnum)[j] = IGRAPH_NAN; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*oldnum)[j] = IGRAPH_NAN; ------------------ | | 153| 0|#define IGRAPH_NAN ((double)NAN) ------------------ 424| 0| } 425| 0| break; 426| 0| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (426:13): [True: 0, False: 0] ------------------ 427| 0| IGRAPH_CHECK(igraph_strvector_resize(oldstr, origlen + nv)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 428| 0| break; 429| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (429:13): [True: 0, False: 0] ------------------ 430| 0| IGRAPH_CHECK(igraph_vector_bool_resize(oldbool, origlen + nv)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 431| 0| for (j = origlen; j < origlen + nv; j++) { ------------------ | Branch (431:35): [True: 0, False: 0] ------------------ 432| 0| VECTOR(*oldbool)[j] = 0; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 433| 0| } 434| 0| break; 435| 0| default: ------------------ | Branch (435:13): [True: 0, False: 0] ------------------ 436| 0| IGRAPH_WARNING("Invalid attribute type"); ------------------ | | 939| 0| do { \ | | 940| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 941| 0| } while (0) | | ------------------ | | | Branch (941:14): [Folded - Ignored] | | ------------------ ------------------ 437| 0| break; 438| 0| } 439| 0| } 440| 201| } 441| | 442| 1.64k| igraph_vector_int_destroy(&news); 443| 1.64k| IGRAPH_FINALLY_CLEAN(1); 444| | 445| 1.64k| return IGRAPH_SUCCESS; 446| 1.78k|} cattributes.c:igraph_i_cattribute_revert_attribute_vector_sizes: 61| 144| igraph_vector_ptr_t *attrlist, igraph_integer_t origlen) { 62| | 63| 144| igraph_integer_t no_of_attrs = igraph_vector_ptr_size(attrlist); 64| 288| for (igraph_integer_t i = 0; i < no_of_attrs; i++) { ------------------ | Branch (64:34): [True: 144, False: 144] ------------------ 65| 144| igraph_attribute_record_t *rec = VECTOR(*attrlist)[i]; ------------------ | | 69| 144|#define VECTOR(v) ((v).stor_begin) ------------------ 66| 144| if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (66:13): [True: 0, False: 144] ------------------ 67| 0| igraph_vector_t *nvec = (igraph_vector_t *) rec->value; 68| 0| IGRAPH_ASSERT(igraph_vector_capacity(nvec) >= origlen); ------------------ | | 1107| 0| do { \ | | 1108| 0| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 0| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 69| 0| igraph_vector_resize(nvec, origlen); /* shrinks */ 70| 144| } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) { ------------------ | Branch (70:20): [True: 0, False: 144] ------------------ 71| 0| igraph_vector_bool_t *bvec = (igraph_vector_bool_t *) rec->value; 72| 0| IGRAPH_ASSERT(igraph_vector_bool_capacity(bvec) >= origlen); ------------------ | | 1107| 0| do { \ | | 1108| 0| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 0| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 73| 0| igraph_vector_bool_resize(bvec, origlen); /* shrinks */ 74| 144| } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) { ------------------ | Branch (74:20): [True: 144, False: 0] ------------------ 75| 144| igraph_strvector_t *svec = (igraph_strvector_t *) rec->value; 76| 144| IGRAPH_ASSERT(igraph_strvector_capacity(svec) >= origlen); ------------------ | | 1107| 144| do { \ | | 1108| 144| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 144| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 144] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 144| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 77| 144| igraph_strvector_resize(svec, origlen); /* shrinks */ 78| 144| } else { 79| | /* Must never reach here */ 80| 0| IGRAPH_FATAL("Unknown attribute type encountered."); ------------------ | | 1078| 0| do { \ | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1080| 0| } while (0) | | ------------------ | | | Branch (1080:14): [Folded - Ignored] | | ------------------ ------------------ 81| 0| } 82| 144| } 83| 144|} cattributes.c:igraph_i_cattribute_add_edges: 1997| 468| igraph_vector_ptr_t *nattr) { 1998| | /* Record information needed to restore attribute vector sizes */ 1999| 468| igraph_i_cattributes_t *attr = graph->attr; 2000| 468| igraph_vector_ptr_t *eal = &attr->eal; 2001| 468| igraph_integer_t ne = igraph_vector_int_size(edges) / 2; 2002| 468| igraph_integer_t origlen = igraph_ecount(graph) - ne; 2003| | 2004| | /* Attempt adding attributes */ 2005| 468| igraph_error_t err = igraph_i_cattribute_add_edges_inner(graph, edges, nattr); 2006| 468| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (2006:9): [True: 0, False: 468] ------------------ 2007| | /* If unsuccessful, revert attribute vector sizes. 2008| | * The following function assumes that all attributes vectors that 2009| | * are present have a length at least as great as origlen. 2010| | * This is true at the moment because any new attributes that are 2011| | * added to the graph are created directly at 'origlen' instead of 2012| | * being created at smaller sizes and resized later. 2013| | * 2014| | * NOTE: While this ensures that all attribute vector lengths are 2015| | * correct, it does not ensure that no extra attributes have 2016| | * been added to the graph. However, the presence of extra 2017| | * attributes does not make the attribute table inconsistent 2018| | * like the incorrect attribute vector lengths would. 2019| | */ 2020| 0| igraph_i_cattribute_revert_attribute_vector_sizes(eal, origlen); 2021| 0| } 2022| 468| return err; 2023| 468|} cattributes.c:igraph_i_cattribute_add_edges_inner: 1834| 468| igraph_vector_ptr_t *nattr) { 1835| | 1836| 468| igraph_i_cattributes_t *attr = graph->attr; 1837| 468| igraph_vector_ptr_t *eal = &attr->eal; 1838| 468| igraph_integer_t ealno = igraph_vector_ptr_size(eal); 1839| 468| igraph_integer_t ne = igraph_vector_int_size(edges) / 2; 1840| 468| igraph_integer_t origlen = igraph_ecount(graph) - ne; 1841| 468| igraph_integer_t nattrno = nattr == 0 ? 0 : igraph_vector_ptr_size(nattr); ------------------ | Branch (1841:32): [True: 373, False: 95] ------------------ 1842| 468| igraph_vector_int_t news; 1843| 468| igraph_integer_t newattrs, i; 1844| | 1845| | /* First add the new attributes if any */ 1846| 468| newattrs = 0; 1847| 468| IGRAPH_VECTOR_INT_INIT_FINALLY(&news, 0); ------------------ | | 124| 468| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 468| do { \ | | | | 753| 468| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 468| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 468| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 468] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 468| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 468| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 468| do { \ | | | | 696| 468| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 468| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 468| * incorrect destructor function with the pointer */ \ | | | | 699| 468| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 468| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 468| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1848| 563| for (i = 0; i < nattrno; i++) { ------------------ | Branch (1848:17): [True: 95, False: 468] ------------------ 1849| 95| igraph_attribute_record_t *nattr_entry = VECTOR(*nattr)[i]; ------------------ | | 69| 95|#define VECTOR(v) ((v).stor_begin) ------------------ 1850| 95| const char *nname = nattr_entry->name; 1851| 95| igraph_integer_t j; 1852| 95| igraph_bool_t l = igraph_i_cattribute_find(eal, nname, &j); 1853| 95| if (!l) { ------------------ | Branch (1853:13): [True: 95, False: 0] ------------------ 1854| 95| newattrs++; 1855| 95| IGRAPH_CHECK(igraph_vector_int_push_back(&news, i)); ------------------ | | 752| 95| do { \ | | 753| 95| igraph_error_t igraph_i_ret = (expr); \ | | 754| 95| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 95| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 95] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 95| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1856| 95| } else { 1857| | /* check types */ 1858| 0| if (nattr_entry->type != ------------------ | Branch (1858:17): [True: 0, False: 0] ------------------ 1859| 0| ((igraph_attribute_record_t*)VECTOR(*eal)[j])->type) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1860| 0| IGRAPH_ERROR("You cannot mix attribute types", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1861| 0| } 1862| 0| } 1863| 95| } 1864| | 1865| | /* Add NaN/false/"" for the existing vertices for numeric, boolean and string attributes. */ 1866| 468| if (newattrs != 0) { ------------------ | Branch (1866:9): [True: 95, False: 373] ------------------ 1867| 190| for (i = 0; i < newattrs; i++) { ------------------ | Branch (1867:21): [True: 95, False: 95] ------------------ 1868| 95| igraph_attribute_record_t *tmp = VECTOR(*nattr)[ VECTOR(news)[i] ]; ------------------ | | 69| 95|#define VECTOR(v) ((v).stor_begin) ------------------ igraph_attribute_record_t *tmp = VECTOR(*nattr)[ VECTOR(news)[i] ]; ------------------ | | 69| 95|#define VECTOR(v) ((v).stor_begin) ------------------ 1869| 95| igraph_attribute_record_t *newrec = IGRAPH_CALLOC(1, igraph_attribute_record_t); ------------------ | | 32| 95|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 1870| 95| igraph_attribute_type_t type = tmp->type; 1871| 95| if (!newrec) { ------------------ | Branch (1871:17): [True: 0, False: 95] ------------------ 1872| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1873| 0| } 1874| 95| IGRAPH_FINALLY(igraph_free, newrec); ------------------ | | 695| 95| do { \ | | 696| 95| /* the following branch makes the compiler check the compatibility of \ | | 697| 95| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 95| * incorrect destructor function with the pointer */ \ | | 699| 95| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 95| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 95| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1875| 95| newrec->type = type; 1876| 95| newrec->name = strdup(tmp->name); 1877| 95| if (!newrec->name) { ------------------ | Branch (1877:17): [True: 0, False: 95] ------------------ 1878| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1879| 0| } 1880| 95| IGRAPH_FINALLY(igraph_free, (char*)newrec->name); ------------------ | | 695| 95| do { \ | | 696| 95| /* the following branch makes the compiler check the compatibility of \ | | 697| 95| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 95| * incorrect destructor function with the pointer */ \ | | 699| 95| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 95| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 95| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1881| 95| if (type == IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (1881:17): [True: 95, False: 0] ------------------ 1882| 95| igraph_vector_t *newnum = IGRAPH_CALLOC(1, igraph_vector_t); ------------------ | | 32| 95|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 1883| 95| if (!newnum) { ------------------ | Branch (1883:21): [True: 0, False: 95] ------------------ 1884| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1885| 0| } 1886| 95| IGRAPH_FINALLY(igraph_free, newnum); ------------------ | | 695| 95| do { \ | | 696| 95| /* the following branch makes the compiler check the compatibility of \ | | 697| 95| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 95| * incorrect destructor function with the pointer */ \ | | 699| 95| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 95| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 95| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1887| 95| IGRAPH_VECTOR_INIT_FINALLY(newnum, origlen); ------------------ | | 109| 95| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 95| do { \ | | | | 753| 95| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 95| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 95| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 95] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 95| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 95| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 95| do { \ | | | | 696| 95| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 95| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 95| * incorrect destructor function with the pointer */ \ | | | | 699| 95| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 95| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 95| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 1888| 95| newrec->value = newnum; 1889| 95| igraph_vector_fill(newnum, IGRAPH_NAN); ------------------ | | 153| 95|#define IGRAPH_NAN ((double)NAN) ------------------ 1890| 95| } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) { ------------------ | Branch (1890:24): [True: 0, False: 0] ------------------ 1891| 0| igraph_vector_bool_t *newbool = IGRAPH_CALLOC(1, igraph_vector_bool_t); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 1892| 0| if (!newbool) { ------------------ | Branch (1892:21): [True: 0, False: 0] ------------------ 1893| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1894| 0| } 1895| 0| IGRAPH_FINALLY(igraph_free, newbool); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1896| 0| IGRAPH_VECTOR_BOOL_INIT_FINALLY(newbool, origlen); ------------------ | | 114| 0| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 115| 0| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (115:65): [Folded - Ignored] | | ------------------ ------------------ 1897| 0| newrec->value = newbool; 1898| 0| igraph_vector_bool_fill(newbool, false); 1899| 0| } else if (type == IGRAPH_ATTRIBUTE_STRING) { ------------------ | Branch (1899:24): [True: 0, False: 0] ------------------ 1900| 0| igraph_strvector_t *newstr = IGRAPH_CALLOC(1, igraph_strvector_t); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 1901| 0| if (!newstr) { ------------------ | Branch (1901:21): [True: 0, False: 0] ------------------ 1902| 0| IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1903| 0| } 1904| 0| IGRAPH_FINALLY(igraph_free, newstr); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1905| 0| IGRAPH_STRVECTOR_INIT_FINALLY(newstr, origlen); ------------------ | | 63| 0| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 64| 0| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (64:65): [Folded - Ignored] | | ------------------ ------------------ 1906| 0| newrec->value = newstr; 1907| 0| } 1908| 95| IGRAPH_CHECK(igraph_vector_ptr_push_back(eal, newrec)); ------------------ | | 752| 95| do { \ | | 753| 95| igraph_error_t igraph_i_ret = (expr); \ | | 754| 95| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 95| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 95] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 95| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1909| 95| IGRAPH_FINALLY_CLEAN(4); 1910| 95| } 1911| 95| ealno = igraph_vector_ptr_size(eal); 1912| 95| } 1913| | 1914| | /* Now append the new values */ 1915| 563| for (i = 0; i < ealno; i++) { ------------------ | Branch (1915:17): [True: 95, False: 468] ------------------ 1916| 95| igraph_attribute_record_t *oldrec = VECTOR(*eal)[i]; ------------------ | | 69| 95|#define VECTOR(v) ((v).stor_begin) ------------------ 1917| 95| igraph_attribute_record_t *newrec = NULL; 1918| 95| const char *name = oldrec->name; 1919| 95| igraph_integer_t j = -1; 1920| 95| igraph_bool_t l = false; 1921| 95| if (nattr) { ------------------ | Branch (1921:13): [True: 95, False: 0] ------------------ 1922| 95| l = igraph_i_cattribute_find(nattr, name, &j); 1923| 95| } 1924| 95| if (l) { ------------------ | Branch (1924:13): [True: 95, False: 0] ------------------ 1925| | /* This attribute is present in nattr */ 1926| 95| igraph_vector_t *oldnum, *newnum; 1927| 95| igraph_strvector_t *oldstr, *newstr; 1928| 95| igraph_vector_bool_t *oldbool, *newbool; 1929| 95| newrec = VECTOR(*nattr)[j]; ------------------ | | 69| 95|#define VECTOR(v) ((v).stor_begin) ------------------ 1930| 95| oldnum = (igraph_vector_t*)oldrec->value; 1931| 95| newnum = (igraph_vector_t*)newrec->value; 1932| 95| oldstr = (igraph_strvector_t*)oldrec->value; 1933| 95| newstr = (igraph_strvector_t*)newrec->value; 1934| 95| oldbool = (igraph_vector_bool_t*)oldrec->value; 1935| 95| newbool = (igraph_vector_bool_t*)newrec->value; 1936| 95| if (oldrec->type != newrec->type) { ------------------ | Branch (1936:17): [True: 0, False: 95] ------------------ 1937| 0| IGRAPH_ERROR("Attribute types do not match.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1938| 0| } 1939| 95| switch (oldrec->type) { 1940| 95| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (1940:13): [True: 95, False: 0] ------------------ 1941| 95| if (ne != igraph_vector_size(newnum)) { ------------------ | Branch (1941:21): [True: 0, False: 95] ------------------ 1942| 0| IGRAPH_ERROR("Invalid numeric attribute length.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1943| 0| } 1944| 95| IGRAPH_CHECK(igraph_vector_append(oldnum, newnum)); ------------------ | | 752| 95| do { \ | | 753| 95| igraph_error_t igraph_i_ret = (expr); \ | | 754| 95| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 95| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 95] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 95| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1945| 95| break; 1946| 95| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (1946:13): [True: 0, False: 95] ------------------ 1947| 0| if (ne != igraph_strvector_size(newstr)) { ------------------ | Branch (1947:21): [True: 0, False: 0] ------------------ 1948| 0| IGRAPH_ERROR("Invalid string attribute length.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1949| 0| } 1950| 0| IGRAPH_CHECK(igraph_strvector_append(oldstr, newstr)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1951| 0| break; 1952| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (1952:13): [True: 0, False: 95] ------------------ 1953| 0| if (ne != igraph_vector_bool_size(newbool)) { ------------------ | Branch (1953:21): [True: 0, False: 0] ------------------ 1954| 0| IGRAPH_ERROR("Invalid boolean attribute length.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1955| 0| } 1956| 0| IGRAPH_CHECK(igraph_vector_bool_append(oldbool, newbool)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1957| 0| break; 1958| 0| default: ------------------ | Branch (1958:13): [True: 0, False: 95] ------------------ 1959| 0| IGRAPH_WARNING("Invalid attribute type."); ------------------ | | 939| 0| do { \ | | 940| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 941| 0| } while (0) | | ------------------ | | | Branch (941:14): [Folded - Ignored] | | ------------------ ------------------ 1960| 0| break; 1961| 95| } 1962| 95| } else { 1963| | /* No such attribute, append NaN/false/"". */ 1964| 0| igraph_vector_t *oldnum = (igraph_vector_t *)oldrec->value; 1965| 0| igraph_strvector_t *oldstr = (igraph_strvector_t*)oldrec->value; 1966| 0| igraph_vector_bool_t *oldbool = (igraph_vector_bool_t *)oldrec->value; 1967| 0| switch (oldrec->type) { 1968| 0| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (1968:13): [True: 0, False: 0] ------------------ 1969| 0| IGRAPH_CHECK(igraph_vector_resize(oldnum, origlen + ne)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1970| 0| for (j = origlen; j < origlen + ne; j++) { ------------------ | Branch (1970:35): [True: 0, False: 0] ------------------ 1971| 0| VECTOR(*oldnum)[j] = IGRAPH_NAN; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*oldnum)[j] = IGRAPH_NAN; ------------------ | | 153| 0|#define IGRAPH_NAN ((double)NAN) ------------------ 1972| 0| } 1973| 0| break; 1974| 0| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (1974:13): [True: 0, False: 0] ------------------ 1975| 0| IGRAPH_CHECK(igraph_strvector_resize(oldstr, origlen + ne)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1976| 0| break; 1977| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (1977:13): [True: 0, False: 0] ------------------ 1978| 0| IGRAPH_CHECK(igraph_vector_bool_resize(oldbool, origlen + ne)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1979| 0| for (j = origlen; j < origlen + ne; j++) { ------------------ | Branch (1979:35): [True: 0, False: 0] ------------------ 1980| 0| VECTOR(*oldbool)[j] = 0; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1981| 0| } 1982| 0| break; 1983| 0| default: ------------------ | Branch (1983:13): [True: 0, False: 0] ------------------ 1984| 0| IGRAPH_WARNING("Invalid attribute type"); ------------------ | | 939| 0| do { \ | | 940| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 941| 0| } while (0) | | ------------------ | | | Branch (941:14): [Folded - Ignored] | | ------------------ ------------------ 1985| 0| break; 1986| 0| } 1987| 0| } 1988| 95| } 1989| | 1990| 468| igraph_vector_int_destroy(&news); 1991| 468| IGRAPH_FINALLY_CLEAN(1); 1992| | 1993| 468| return IGRAPH_SUCCESS; 1994| 468|} cattributes.c:igraph_i_cattribute_find: 41| 592| const char *name, igraph_integer_t *idx) { 42| 592| igraph_integer_t i, n = igraph_vector_ptr_size(ptrvec); 43| 592| igraph_bool_t l = false; 44| 888| for (i = 0; !l && i < n; i++) { ------------------ | Branch (44:17): [True: 592, False: 296] | Branch (44:23): [True: 296, False: 296] ------------------ 45| 296| igraph_attribute_record_t *rec = VECTOR(*ptrvec)[i]; ------------------ | | 69| 296|#define VECTOR(v) ((v).stor_begin) ------------------ 46| 296| l = !strcmp(rec->name, name); 47| 296| } 48| 592| if (idx) { ------------------ | Branch (48:9): [True: 592, False: 0] ------------------ 49| 592| *idx = i - 1; 50| 592| } 51| 592| return l; 52| 592|} igraph_empty: 65| 892|igraph_error_t igraph_empty(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed) { 66| 892| return igraph_empty_attrs(graph, n, directed, 0); 67| 892|} igraph_empty_attrs: 98| 892|igraph_error_t igraph_empty_attrs(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed, void *attr) { 99| | 100| 892| if (n < 0) { ------------------ | Branch (100:9): [True: 0, False: 892] ------------------ 101| 0| IGRAPH_ERROR("Number of vertices must not be negative.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 102| 0| } 103| | 104| 892| graph->n = 0; 105| 892| graph->directed = directed; 106| 892| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0); ------------------ | | 124| 892| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 892| do { \ | | | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 892] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 892| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 892| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 892| do { \ | | | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 892| * incorrect destructor function with the pointer */ \ | | | | 699| 892| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 892| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 107| 892| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0); ------------------ | | 124| 892| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 892| do { \ | | | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 892] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 892| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 892| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 892| do { \ | | | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 892| * incorrect destructor function with the pointer */ \ | | | | 699| 892| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 892| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 108| 892| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0); ------------------ | | 124| 892| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 892| do { \ | | | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 892] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 892| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 892| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 892| do { \ | | | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 892| * incorrect destructor function with the pointer */ \ | | | | 699| 892| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 892| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 109| 892| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0); ------------------ | | 124| 892| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 892| do { \ | | | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 892] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 892| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 892| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 892| do { \ | | | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 892| * incorrect destructor function with the pointer */ \ | | | | 699| 892| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 892| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 110| 892| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1); ------------------ | | 124| 892| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 892| do { \ | | | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 892] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 892| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 892| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 892| do { \ | | | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 892| * incorrect destructor function with the pointer */ \ | | | | 699| 892| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 892| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 111| 892| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1); ------------------ | | 124| 892| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 892| do { \ | | | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 892] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 892| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 892| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 892| do { \ | | | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 892| * incorrect destructor function with the pointer */ \ | | | | 699| 892| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 892| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 112| | 113| | /* init cache */ 114| 892| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t); ------------------ | | 32| 892|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 115| 892| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph."); ------------------ | | 807| 892| do { \ | | 808| 892| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 892] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 892| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 116| 892| IGRAPH_FINALLY(igraph_free, graph->cache); ------------------ | | 695| 892| do { \ | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 892| * incorrect destructor function with the pointer */ \ | | 699| 892| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 892| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 117| 892| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache)); ------------------ | | 752| 892| do { \ | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 892] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 892| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 118| 892| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache); ------------------ | | 695| 892| do { \ | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 892| * incorrect destructor function with the pointer */ \ | | 699| 892| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 892| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 119| | 120| 892| VECTOR(graph->os)[0] = 0; ------------------ | | 69| 892|#define VECTOR(v) ((v).stor_begin) ------------------ 121| 892| VECTOR(graph->is)[0] = 0; ------------------ | | 69| 892|#define VECTOR(v) ((v).stor_begin) ------------------ 122| | 123| | /* init attributes */ 124| 892| graph->attr = 0; 125| 892| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr)); ------------------ | | 752| 892| do { \ | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 892] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 892| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 126| | 127| | /* add the vertices */ 128| 892| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0)); ------------------ | | 752| 892| do { \ | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 892] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 892| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 129| | 130| 892| IGRAPH_FINALLY_CLEAN(8); 131| 892| return IGRAPH_SUCCESS; 132| 892|} igraph_destroy: 150| 892|void igraph_destroy(igraph_t *graph) { 151| | 152| 892| IGRAPH_I_ATTRIBUTE_DESTROY(graph); ------------------ | | 30| 892| do {if ((graph)->attr) igraph_i_attribute_destroy(graph);} while(0) | | ------------------ | | | Branch (30:13): [True: 892, False: 0] | | | Branch (30:70): [Folded - Ignored] | | ------------------ ------------------ 153| | 154| 892| igraph_i_property_cache_destroy(graph->cache); 155| 892| IGRAPH_FREE(graph->cache); ------------------ | | 35| 892|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 156| | 157| 892| igraph_vector_int_destroy(&graph->from); 158| 892| igraph_vector_int_destroy(&graph->to); 159| 892| igraph_vector_int_destroy(&graph->oi); 160| 892| igraph_vector_int_destroy(&graph->ii); 161| 892| igraph_vector_int_destroy(&graph->os); 162| 892| igraph_vector_int_destroy(&graph->is); 163| 892|} igraph_add_edges: 249| 748| void *attr) { 250| 748| igraph_integer_t no_of_edges = igraph_vector_int_size(&graph->from); 251| 748| igraph_integer_t edges_to_add = igraph_vector_int_size(edges) / 2; 252| 748| igraph_integer_t new_no_of_edges; 253| 748| igraph_integer_t i = 0; 254| 748| igraph_vector_int_t newoi, newii; 255| 748| igraph_bool_t directed = igraph_is_directed(graph); 256| | 257| 748| if (igraph_vector_int_size(edges) % 2 != 0) { ------------------ | Branch (257:9): [True: 0, False: 748] ------------------ 258| 0| IGRAPH_ERROR("Invalid (odd) length of edges vector.", IGRAPH_EINVEVECTOR); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 259| 0| } 260| 748| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) { ------------------ | Branch (260:9): [True: 280, False: 468] ------------------ 261| 280| IGRAPH_ERROR("Out-of-range vertex IDs when adding edges.", IGRAPH_EINVVID); ------------------ | | 493| 280| do { \ | | 494| 280| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 280| return igraph_errno ; \ | | 496| 280| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 262| 280| } 263| | 264| | /* from & to */ 265| 468| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges); ------------------ | | 47| 468| do { \ | | 48| 468| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 468| igraph_integer_t _safe_sum; \ | | 50| 468| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 468] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 468| *(res) = _safe_sum; \ | | 54| 468| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 266| 468| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) { ------------------ | | 122| 468|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2) | | ------------------ | | | | 78| 468|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (266:9): [True: 0, False: 468] ------------------ 267| 0| IGRAPH_ERRORF("Maximum edge count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE, ------------------ | | 550| 0| do { \ | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | 553| 0| return igraph_errno; \ | | 554| 0| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 268| 0| IGRAPH_ECOUNT_MAX); 269| 0| } 270| 468| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add)); ------------------ | | 752| 468| do { \ | | 753| 468| igraph_error_t igraph_i_ret = (expr); \ | | 754| 468| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 468| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 468] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 468| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 271| 468| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add)); ------------------ | | 752| 468| do { \ | | 753| 468| igraph_error_t igraph_i_ret = (expr); \ | | 754| 468| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 468| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 468] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 468| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 272| | 273| 2.38M| while (i < edges_to_add * 2) { ------------------ | Branch (273:12): [True: 2.38M, False: 468] ------------------ 274| 2.38M| if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (274:13): [True: 2.38M, False: 0] | Branch (274:25): [True: 0, False: 0] ------------------ 275| 2.38M| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 69| 2.38M|#define VECTOR(v) ((v).stor_begin) ------------------ 276| 2.38M| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 69| 2.38M|#define VECTOR(v) ((v).stor_begin) ------------------ 277| 2.38M| } else { 278| 0| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 279| 0| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 280| 0| } 281| 2.38M| } 282| | 283| | /* If an error occurs while the edges are being added, we make the necessary fixup 284| | * to ensure that the graph is still in a consistent state when this function returns. 285| | * The graph may already be on the finally stack when calling this function. We use 286| | * a separate finally stack level to avoid its destructor from being called on error, 287| | * so that the fixup can succeed. 288| | */ 289| | 290| 468|#define CHECK_ERR(expr) \ 291| 468| do { \ 292| 468| igraph_error_t err = (expr); \ 293| 468| if (err != IGRAPH_SUCCESS) { \ 294| 468| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ 295| 468| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ 296| 468| IGRAPH_FINALLY_EXIT(); \ 297| 468| IGRAPH_ERROR("Cannot add edges.", err); \ 298| 468| } \ 299| 468| } while (0) 300| | 301| | /* oi & ii */ 302| 468| IGRAPH_FINALLY_ENTER(); 303| 468| { 304| 468| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges)); ------------------ | | 291| 468| do { \ | | 292| 468| igraph_error_t err = (expr); \ | | 293| 468| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 468] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 468| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 305| 468| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi); ------------------ | | 695| 468| do { \ | | 696| 468| /* the following branch makes the compiler check the compatibility of \ | | 697| 468| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 468| * incorrect destructor function with the pointer */ \ | | 699| 468| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 468| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 468| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 306| 468| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges)); ------------------ | | 291| 468| do { \ | | 292| 468| igraph_error_t err = (expr); \ | | 293| 468| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 468] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 468| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 307| 468| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii); ------------------ | | 695| 468| do { \ | | 696| 468| /* the following branch makes the compiler check the compatibility of \ | | 697| 468| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 468| * incorrect destructor function with the pointer */ \ | | 699| 468| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 468| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 468| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 308| 468| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n)); ------------------ | | 291| 468| do { \ | | 292| 468| igraph_error_t err = (expr); \ | | 293| 468| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 468] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 468| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 309| 468| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n)); ------------------ | | 291| 468| do { \ | | 292| 468| igraph_error_t err = (expr); \ | | 293| 468| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 468] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 468| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 310| | 311| | /* Attributes */ 312| 468| if (graph->attr) { ------------------ | Branch (312:13): [True: 468, False: 0] ------------------ 313| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */ 314| 468| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr)); ------------------ | | 291| 468| do { \ | | 292| 468| igraph_error_t err = (expr); \ | | 293| 468| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 468] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 468| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 315| 468| } 316| | 317| | /* os & is, its length does not change, error safe */ 318| 468| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n); 319| 468| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n); 320| | 321| | /* everything went fine */ 322| 468| igraph_vector_int_destroy(&graph->oi); 323| 468| igraph_vector_int_destroy(&graph->ii); 324| 468| IGRAPH_FINALLY_CLEAN(2); 325| | 326| 468| graph->oi = newoi; 327| 468| graph->ii = newii; 328| 468| } 329| 0| IGRAPH_FINALLY_EXIT(); 330| | 331| 468|#undef CHECK_ERR 332| | 333| | /* modification successful, clear the cached properties of the graph. 334| | * 335| | * Adding one or more edges cannot make a strongly or weakly connected 336| | * graph disconnected, so we keep those flags if they are cached as true. 337| | * 338| | * Adding one or more edges may turn a DAG into a non-DAG or a forest into 339| | * a non-forest, so we can keep those flags only if they are cached as 340| | * false. 341| | * 342| | * Also, adding one or more edges does not change HAS_LOOP, HAS_MULTI and 343| | * HAS_MUTUAL if they were already true. 344| | */ 345| 468| igraph_i_property_cache_invalidate_conditionally( 346| 468| graph, 347| 468| /* keep_always = */ 0, 348| | /* keep_when_false = */ 349| 468| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST), 350| | /* keep_when_true = */ 351| 468| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) | 352| 468| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 353| 468| (1 << IGRAPH_PROP_HAS_LOOP) | 354| 468| (1 << IGRAPH_PROP_HAS_MULTI) | 355| 468| (1 << IGRAPH_PROP_HAS_MUTUAL) 356| 468| ); 357| | 358| 468| return IGRAPH_SUCCESS; 359| 468|} igraph_add_vertices: 381| 1.78k|igraph_error_t igraph_add_vertices(igraph_t *graph, igraph_integer_t nv, void *attr) { 382| 1.78k| igraph_integer_t ec = igraph_ecount(graph); 383| 1.78k| igraph_integer_t vc = igraph_vcount(graph); 384| 1.78k| igraph_integer_t new_vc; 385| 1.78k| igraph_integer_t i; 386| | 387| 1.78k| if (nv < 0) { ------------------ | Branch (387:9): [True: 0, False: 1.78k] ------------------ 388| 0| IGRAPH_ERROR("Cannot add negative number of vertices.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 389| 0| } 390| | 391| 1.78k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc); ------------------ | | 47| 1.78k| do { \ | | 48| 1.78k| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 1.78k| igraph_integer_t _safe_sum; \ | | 50| 1.78k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 1.78k] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 1.78k| *(res) = _safe_sum; \ | | 54| 1.78k| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 392| 1.78k| if (new_vc > IGRAPH_VCOUNT_MAX) { ------------------ | | 106| 1.78k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1) | | ------------------ | | | | 78| 1.78k|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (392:9): [True: 0, False: 1.78k] ------------------ 393| 0| IGRAPH_ERRORF("Maximum vertex count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE, ------------------ | | 550| 0| do { \ | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | 553| 0| return igraph_errno; \ | | 554| 0| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 394| 0| IGRAPH_VCOUNT_MAX); 395| 0| } 396| 1.78k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1)); ------------------ | | 752| 1.78k| do { \ | | 753| 1.78k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.78k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.78k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.78k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.78k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 397| 1.78k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1)); ------------------ | | 752| 1.78k| do { \ | | 753| 1.78k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.78k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.78k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.78k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.78k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 398| | 399| 1.78k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */ 400| 1.78k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */ 401| 135M| for (i = graph->n + 1; i < new_vc + 1; i++) { ------------------ | Branch (401:28): [True: 135M, False: 1.78k] ------------------ 402| 135M| VECTOR(graph->os)[i] = ec; ------------------ | | 69| 135M|#define VECTOR(v) ((v).stor_begin) ------------------ 403| 135M| VECTOR(graph->is)[i] = ec; ------------------ | | 69| 135M|#define VECTOR(v) ((v).stor_begin) ------------------ 404| 135M| } 405| | 406| 1.78k| graph->n += nv; 407| | 408| | /* Add attributes if necessary. This section is protected with 409| | * FINALLY_ENTER/EXIT so that the graph would not be accidentally 410| | * free upon error until it could be restored to a consistant state. */ 411| | 412| 1.78k| if (graph->attr) { ------------------ | Branch (412:9): [True: 1.78k, False: 0] ------------------ 413| 1.78k| igraph_error_t err; 414| 1.78k| IGRAPH_FINALLY_ENTER(); 415| 1.78k| err = igraph_i_attribute_add_vertices(graph, nv, attr); 416| 1.78k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (416:13): [True: 144, False: 1.64k] ------------------ 417| | /* Restore original vertex count on failure */ 418| 144| graph->n = vc; 419| 144| igraph_vector_int_resize(&graph->os, vc + 1); /* shrinks */ 420| 144| igraph_vector_int_resize(&graph->is, vc + 1); /* shrinks */ 421| 144| } 422| 1.78k| IGRAPH_FINALLY_EXIT(); 423| 1.78k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (423:13): [True: 144, False: 1.64k] ------------------ 424| 144| IGRAPH_ERROR("Cannot add vertices.", err); ------------------ | | 493| 144| do { \ | | 494| 144| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 144| return igraph_errno ; \ | | 496| 144| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 425| 144| } 426| 1.78k| } 427| | 428| | /* modification successful, clear the cached properties of the graph. 429| | * 430| | * Adding one or more nodes does not change the following cached properties: 431| | * 432| | * - IGRAPH_PROP_HAS_LOOP 433| | * - IGRAPH_PROP_HAS_MULTI 434| | * - IGRAPH_PROP_HAS_MUTUAL 435| | * - IGRAPH_PROP_IS_DAG (adding a node does not create/destroy cycles) 436| | * - IGRAPH_PROP_IS_FOREST (same) 437| | * 438| | * Adding one or more nodes without any edges incident on them is sure to 439| | * make the graph disconnected (weakly or strongly), so we can keep the 440| | * connectivity-related properties if they are currently cached as false. 441| | * (Actually, even if they weren't cached as false, we could still set them 442| | * to false, but we don't have that functionality yet). The only exception 443| | * is when the graph had zero vertices and gained only one vertex, because 444| | * it then becomes connected. That's why we have the condition below in the 445| | * keep_when_false section. 446| | */ 447| 1.64k| igraph_i_property_cache_invalidate_conditionally( 448| 1.64k| graph, 449| | /* keep_always = */ 450| 1.64k| (1 << IGRAPH_PROP_HAS_LOOP) | 451| 1.64k| (1 << IGRAPH_PROP_HAS_MULTI) | 452| 1.64k| (1 << IGRAPH_PROP_HAS_MUTUAL) | 453| 1.64k| (1 << IGRAPH_PROP_IS_DAG) | 454| 1.64k| (1 << IGRAPH_PROP_IS_FOREST), 455| | /* keep_when_false = */ 456| 1.64k| igraph_vcount(graph) >= 2 ? ( ------------------ | Branch (456:9): [True: 698, False: 942] ------------------ 457| 698| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 458| 698| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) 459| 942| ) : 0, 460| | /* keep_when_true = */ 461| 1.64k| 0 462| 1.64k| ); 463| | 464| 1.64k| return IGRAPH_SUCCESS; 465| 1.78k|} igraph_vcount: 824| 7.74k|igraph_integer_t igraph_vcount(const igraph_t *graph) { 825| 7.74k| return graph->n; 826| 7.74k|} igraph_ecount: 838| 2.72k|igraph_integer_t igraph_ecount(const igraph_t *graph) { 839| 2.72k| return igraph_vector_int_size(&graph->from); 840| 2.72k|} igraph_is_directed: 1104| 748|igraph_bool_t igraph_is_directed(const igraph_t *graph) { 1105| 748| return graph->directed; 1106| 748|} type_indexededgelist.c:igraph_i_create_start_vectors: 1047| 936| igraph_vector_int_t *iindex, igraph_integer_t nodes) { 1048| | 1049| 936|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) 1050| | 1051| 936| igraph_integer_t no_of_nodes; 1052| 936| igraph_integer_t no_of_edges; 1053| 936| igraph_integer_t i, j, idx; 1054| | 1055| 936| no_of_nodes = nodes; 1056| 936| no_of_edges = igraph_vector_int_size(el); 1057| | 1058| | /* result */ 1059| | 1060| 936| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1)); ------------------ | | 752| 936| do { \ | | 753| 936| igraph_error_t igraph_i_ret = (expr); \ | | 754| 936| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 936| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 936] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 936| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1061| | 1062| | /* create the index */ 1063| | 1064| 936| if (no_of_edges == 0) { ------------------ | Branch (1064:9): [True: 316, False: 620] ------------------ 1065| | /* empty graph */ 1066| 316| igraph_vector_int_null(res); 1067| 620| } else { 1068| 620| idx = -1; 1069| 2.85M| for (i = 0; i <= EDGE(0); i++) { ------------------ | | 1049| 2.85M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 2.85M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 2.85M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (1069:21): [True: 2.85M, False: 620] ------------------ 1070| 2.85M| idx++; VECTOR(*res)[idx] = 0; ------------------ | | 69| 2.85M|#define VECTOR(v) ((v).stor_begin) ------------------ 1071| 2.85M| } 1072| 4.76M| for (i = 1; i < no_of_edges; i++) { ------------------ | Branch (1072:21): [True: 4.75M, False: 620] ------------------ 1073| 4.75M| igraph_integer_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1049| 4.75M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 4.75M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 4.75M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ igraph_integer_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1049| 4.75M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 4.75M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 4.75M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1074| 8.08M| for (j = 0; j < n; j++) { ------------------ | Branch (1074:25): [True: 3.32M, False: 4.75M] ------------------ 1075| 3.32M| idx++; VECTOR(*res)[idx] = i; ------------------ | | 69| 3.32M|#define VECTOR(v) ((v).stor_begin) ------------------ 1076| 3.32M| } 1077| 4.75M| } 1078| 620| j = EDGE(VECTOR(*res)[idx]); ------------------ | | 1049| 620|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 620|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 620|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1079| 26.4M| for (i = 0; i < no_of_nodes - j; i++) { ------------------ | Branch (1079:21): [True: 26.4M, False: 620] ------------------ 1080| 26.4M| idx++; VECTOR(*res)[idx] = no_of_edges; ------------------ | | 69| 26.4M|#define VECTOR(v) ((v).stor_begin) ------------------ 1081| 26.4M| } 1082| 620| } 1083| | 1084| | /* clean */ 1085| | 1086| 936|# undef EDGE 1087| 936| return IGRAPH_SUCCESS; 1088| 936|} igraph_dl_yylex_destroy_wrapper: 38| 1.98k|void igraph_dl_yylex_destroy_wrapper (void *scanner ) { 39| 1.98k| (void) igraph_dl_yylex_destroy(scanner); 40| 1.98k|} igraph_read_graph_dl: 68| 2.45k| igraph_bool_t directed) { 69| | 70| 2.45k| igraph_integer_t n, n2; 71| 2.45k| const igraph_strvector_t *namevec = 0; 72| 2.45k| igraph_vector_ptr_t name, weight; 73| 2.45k| igraph_vector_ptr_t *pname = 0, *pweight = 0; 74| 2.45k| igraph_attribute_record_t namerec, weightrec; 75| 2.45k| const char *namestr = "name", *weightstr = "weight"; 76| 2.45k| igraph_i_dl_parsedata_t context; 77| | 78| 2.45k| context.eof = 0; 79| 2.45k| context.mode = 0; 80| 2.45k| context.n = -1; 81| 2.45k| context.from = 0; 82| 2.45k| context.to = 0; 83| 2.45k| context.errmsg[0] = '\0'; 84| 2.45k| context.igraph_errno = IGRAPH_SUCCESS; 85| | 86| 2.45k| IGRAPH_VECTOR_INT_INIT_FINALLY(&context.edges, 0); ------------------ | | 124| 2.45k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 2.45k| do { \ | | | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 2.45k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 2.45k| do { \ | | | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.45k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 87| 2.45k| IGRAPH_VECTOR_INIT_FINALLY(&context.weights, 0); ------------------ | | 109| 2.45k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 2.45k| do { \ | | | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 2.45k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 2.45k| do { \ | | | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.45k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 88| 2.45k| IGRAPH_CHECK(igraph_strvector_init(&context.labels, 0)); ------------------ | | 752| 2.45k| do { \ | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 2.45k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 89| 2.45k| IGRAPH_FINALLY(igraph_strvector_destroy, &context.labels); ------------------ | | 695| 2.45k| do { \ | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | 699| 2.45k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 2.45k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 90| 2.45k| IGRAPH_TRIE_INIT_FINALLY(&context.trie, /*names=*/ 1); ------------------ | | 56| 2.45k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \ | | ------------------ | | | | 752| 2.45k| do { \ | | | | 753| 2.45k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 2.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 2.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 2.45k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 57| 2.45k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0) | | ------------------ | | | | 695| 2.45k| do { \ | | | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | | | 699| 2.45k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 2.45k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (57:59): [Folded - Ignored] | | ------------------ ------------------ 91| | 92| 2.45k| igraph_dl_yylex_init_extra(&context, &context.scanner); 93| 2.45k| IGRAPH_FINALLY(igraph_dl_yylex_destroy_wrapper, context.scanner); ------------------ | | 695| 2.45k| do { \ | | 696| 2.45k| /* the following branch makes the compiler check the compatibility of \ | | 697| 2.45k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 2.45k| * incorrect destructor function with the pointer */ \ | | 699| 2.45k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 2.45k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 2.45k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 94| | 95| 2.45k| igraph_dl_yyset_in(instream, context.scanner); 96| | 97| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */ 98| 2.45k| IGRAPH_FINALLY_ENTER(); 99| 2.45k| int err = igraph_dl_yyparse(&context); 100| 2.45k| IGRAPH_FINALLY_EXIT(); 101| 2.45k| switch (err) { 102| 892| case 0: /* success */ ------------------ | Branch (102:5): [True: 892, False: 1.56k] ------------------ 103| 892| break; 104| 1.56k| case 1: /* parse error */ ------------------ | Branch (104:5): [True: 1.56k, False: 892] ------------------ 105| 1.56k| if (context.errmsg[0] != 0) { ------------------ | Branch (105:13): [True: 1.50k, False: 52] ------------------ 106| 1.50k| IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR); ------------------ | | 493| 1.50k| do { \ | | 494| 1.50k| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 1.50k| return igraph_errno ; \ | | 496| 1.50k| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 107| 1.50k| } else if (context.igraph_errno != IGRAPH_SUCCESS) { ------------------ | Branch (107:20): [True: 52, False: 0] ------------------ 108| 52| IGRAPH_ERROR("", context.igraph_errno); ------------------ | | 493| 52| do { \ | | 494| 52| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 52| return igraph_errno ; \ | | 496| 52| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 109| 52| } else { 110| 0| IGRAPH_ERROR("Cannot read DL file.", IGRAPH_PARSEERROR); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 111| 0| } 112| 0| break; 113| 0| case 2: /* out of memory */ ------------------ | Branch (113:5): [True: 0, False: 2.45k] ------------------ 114| 0| IGRAPH_ERROR("Cannot read DL file.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 115| 0| break; 116| 0| default: /* must never reach here */ ------------------ | Branch (116:5): [True: 0, False: 2.45k] ------------------ 117| | /* Hint: This will usually be triggered if an IGRAPH_CHECK() is used in a Bison 118| | * action instead of an IGRAPH_YY_CHECK(), resulting in an igraph errno being 119| | * returned in place of a Bison error code. 120| | * TODO: What if future Bison versions introduce error codes other than 0, 1 and 2? 121| | */ 122| 0| IGRAPH_FATALF("Parser returned unexpected error code (%d) when reading DL file.", err); ------------------ | | 1058| 0| do { \ | | 1059| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 1060| 0| __VA_ARGS__); \ | | 1061| 0| } while (0) | | ------------------ | | | Branch (1061:14): [Folded - Ignored] | | ------------------ ------------------ 123| 2.45k| } 124| | 125| | /* Extend the weight vector, if needed */ 126| 892| n = igraph_vector_size(&context.weights); 127| 892| n2 = igraph_vector_int_size(&context.edges) / 2; 128| 892| if (n != 0) { ------------------ | Branch (128:9): [True: 249, False: 643] ------------------ 129| 249| IGRAPH_CHECK(igraph_vector_resize(&context.weights, n2)); ------------------ | | 752| 249| do { \ | | 753| 249| igraph_error_t igraph_i_ret = (expr); \ | | 754| 249| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 249| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 249] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 249| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 130| 1.10k| for (; n < n2; n++) { ------------------ | Branch (130:16): [True: 854, False: 249] ------------------ 131| 854| VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 69| 854|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 153| 854|#define IGRAPH_NAN ((double)NAN) ------------------ 132| 854| } 133| 249| } 134| | 135| | /* Check number of vertices */ 136| 892| if (n2 > 0) { ------------------ | Branch (136:9): [True: 654, False: 238] ------------------ 137| 654| n = igraph_vector_int_max(&context.edges); 138| 654| } else { 139| 238| n = 0; 140| 238| } 141| 892| if (n >= context.n) { ------------------ | Branch (141:9): [True: 389, False: 503] ------------------ 142| 389| IGRAPH_WARNING("More vertices than specified in `DL' file"); ------------------ | | 939| 389| do { \ | | 940| 389| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 941| 389| } while (0) | | ------------------ | | | Branch (941:14): [Folded - Ignored] | | ------------------ ------------------ 143| 389| context.n = n; 144| 389| } 145| | 146| | /* Prepare attributes */ 147| | 148| | /* Labels */ 149| 892| if (igraph_strvector_size(&context.labels) != 0) { ------------------ | Branch (149:9): [True: 114, False: 778] ------------------ 150| 114| namevec = (const igraph_strvector_t*) &context.labels; 151| 778| } else if (igraph_trie_size(&context.trie) != 0) { ------------------ | Branch (151:16): [True: 87, False: 691] ------------------ 152| 87| namevec = igraph_i_trie_borrow_keys(&context.trie); 153| 87| } 154| 892| if (namevec) { ------------------ | Branch (154:9): [True: 201, False: 691] ------------------ 155| 201| IGRAPH_CHECK(igraph_vector_ptr_init(&name, 1)); ------------------ | | 752| 201| do { \ | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 201] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 201| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 156| 201| IGRAPH_FINALLY(igraph_vector_ptr_destroy, &name); ------------------ | | 695| 201| do { \ | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 201| * incorrect destructor function with the pointer */ \ | | 699| 201| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 201| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 157| 201| pname = &name; 158| 201| namerec.name = namestr; 159| 201| namerec.type = IGRAPH_ATTRIBUTE_STRING; 160| 201| namerec.value = namevec; 161| 201| VECTOR(name)[0] = &namerec; ------------------ | | 69| 201|#define VECTOR(v) ((v).stor_begin) ------------------ 162| 201| } 163| | 164| | /* Weights */ 165| 892| if (igraph_vector_size(&context.weights) != 0) { ------------------ | Branch (165:9): [True: 249, False: 643] ------------------ 166| 249| IGRAPH_CHECK(igraph_vector_ptr_init(&weight, 1)); ------------------ | | 752| 249| do { \ | | 753| 249| igraph_error_t igraph_i_ret = (expr); \ | | 754| 249| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 249| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 249] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 249| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 167| 249| IGRAPH_FINALLY(igraph_vector_ptr_destroy, &weight); ------------------ | | 695| 249| do { \ | | 696| 249| /* the following branch makes the compiler check the compatibility of \ | | 697| 249| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 249| * incorrect destructor function with the pointer */ \ | | 699| 249| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 249| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 249| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 168| 249| pweight = &weight; 169| 249| weightrec.name = weightstr; 170| 249| weightrec.type = IGRAPH_ATTRIBUTE_NUMERIC; 171| 249| weightrec.value = &context.weights; 172| 249| VECTOR(weight)[0] = &weightrec; ------------------ | | 69| 249|#define VECTOR(v) ((v).stor_begin) ------------------ 173| 249| } 174| | 175| | /* Create graph */ 176| 892| IGRAPH_CHECK(igraph_empty(graph, 0, directed)); ------------------ | | 752| 892| do { \ | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 892] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 892| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 177| 892| IGRAPH_FINALLY(igraph_destroy, graph); ------------------ | | 695| 892| do { \ | | 696| 892| /* the following branch makes the compiler check the compatibility of \ | | 697| 892| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 892| * incorrect destructor function with the pointer */ \ | | 699| 892| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 892| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 892| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 178| 892| IGRAPH_CHECK(igraph_add_vertices(graph, context.n, pname)); ------------------ | | 752| 892| do { \ | | 753| 892| igraph_error_t igraph_i_ret = (expr); \ | | 754| 892| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 892| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 144, False: 748] | | | | ------------------ | | ------------------ | | 755| 144| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 144| do { \ | | | | 494| 144| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 144| return igraph_errno ; \ | | | | 496| 144| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 144| } \ | | 757| 892| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 179| 748| IGRAPH_CHECK(igraph_add_edges(graph, &context.edges, pweight)); ------------------ | | 752| 748| do { \ | | 753| 748| igraph_error_t igraph_i_ret = (expr); \ | | 754| 748| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 748| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 280, False: 468] | | | | ------------------ | | ------------------ | | 755| 280| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 280| do { \ | | | | 494| 280| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 280| return igraph_errno ; \ | | | | 496| 280| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 280| } \ | | 757| 748| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 180| | 181| 468| if (pweight) { ------------------ | Branch (181:9): [True: 95, False: 373] ------------------ 182| 95| igraph_vector_ptr_destroy(pweight); 183| 95| IGRAPH_FINALLY_CLEAN(1); 184| 95| } 185| | 186| 468| if (pname) { ------------------ | Branch (186:9): [True: 57, False: 411] ------------------ 187| 57| igraph_vector_ptr_destroy(pname); 188| 57| IGRAPH_FINALLY_CLEAN(1); 189| 57| } 190| | 191| | /* don't destroy the graph itself but pop it from the finally stack */ 192| 468| IGRAPH_FINALLY_CLEAN(1); 193| | 194| 468| igraph_trie_destroy(&context.trie); 195| 468| igraph_strvector_destroy(&context.labels); 196| 468| igraph_vector_int_destroy(&context.edges); 197| 468| igraph_vector_destroy(&context.weights); 198| 468| igraph_dl_yylex_destroy(context.scanner); 199| 468| IGRAPH_FINALLY_CLEAN(5); 200| | 201| 468| return IGRAPH_SUCCESS; 202| 748|} igraph_i_parse_integer: 52| 3.98M|igraph_error_t igraph_i_parse_integer(const char *str, size_t length, igraph_integer_t *value) { 53| 3.98M| char buffer[128]; 54| 3.98M| char *tmp, *end; 55| 3.98M| char last_char; 56| 3.98M| igraph_bool_t out_of_range, dynamic_alloc; 57| 3.98M| long long val; 58| | 59| 3.98M| if (length == 0) { ------------------ | Branch (59:9): [True: 0, False: 3.98M] ------------------ 60| 0| IGRAPH_ERROR("Cannot parse integer from empty string.", IGRAPH_PARSEERROR); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 61| 0| } 62| | 63| 3.98M| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]); 64| | 65| 3.98M| if (dynamic_alloc) { ------------------ | Branch (65:9): [True: 207, False: 3.97M] ------------------ 66| 207| tmp = IGRAPH_CALLOC(length+1, char); ------------------ | | 32| 207|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 207, False: 0] | | ------------------ ------------------ 67| 207| IGRAPH_CHECK_OOM(tmp, "Failed to parse integer."); ------------------ | | 807| 207| do { \ | | 808| 207| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 207| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 207] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 207| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 68| 3.97M| } else { 69| 3.97M| tmp = buffer; 70| 3.97M| } 71| | 72| 3.98M| strncpy(tmp, str, length); 73| 3.98M| 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| 3.98M| errno = 0; 79| 3.98M| val = strtoll(tmp, &end, 10); 80| 3.98M| out_of_range = errno == ERANGE; 81| 3.98M| *value = (igraph_integer_t) val; 82| 3.98M| last_char = *end; 83| 3.98M| if (*value != val) { ------------------ | Branch (83:9): [True: 0, False: 3.98M] ------------------ 84| 0| out_of_range = 1; 85| 0| } 86| | 87| | /* Free memory before raising any errors. */ 88| 3.98M| if (dynamic_alloc) { ------------------ | Branch (88:9): [True: 207, False: 3.97M] ------------------ 89| 207| IGRAPH_FREE(tmp); ------------------ | | 35| 207|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 90| 207| } 91| | 92| 3.98M| if (out_of_range) { ------------------ | Branch (92:9): [True: 30, False: 3.98M] ------------------ 93| 30| IGRAPH_ERROR("Failed to parse integer.", val > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 493| 30| do { \ | | 494| 60| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (494:63): [True: 29, False: 1] | | ------------------ | | 495| 60| return igraph_errno ; \ | | ------------------ | | | Branch (495:16): [True: 29, False: 1] | | ------------------ | | 496| 30| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 94| 30| } 95| | 96| | /* Did we parse to the end of the string? */ 97| 3.98M| if (last_char) { ------------------ | Branch (97:9): [True: 1, False: 3.98M] ------------------ 98| 1| IGRAPH_ERRORF("Unexpected character '%c' while parsing integer.", IGRAPH_PARSEERROR, last_char); ------------------ | | 550| 1| do { \ | | 551| 1| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 1| igraph_errno, __VA_ARGS__) ; \ | | 553| 1| return igraph_errno; \ | | 554| 1| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 99| 1| } 100| | 101| 3.98M| return IGRAPH_SUCCESS; 102| 3.98M|} igraph_i_parse_real: 113| 60.8k|igraph_error_t igraph_i_parse_real(const char *str, size_t length, igraph_real_t *value) { 114| 60.8k| char buffer[128]; 115| 60.8k| char *tmp, *end; 116| 60.8k| char last_char; 117| 60.8k| igraph_bool_t out_of_range, dynamic_alloc; 118| | 119| 60.8k| if (length == 0) { ------------------ | Branch (119:9): [True: 0, False: 60.8k] ------------------ 120| 0| IGRAPH_ERROR("Cannot parse real number from empty string.", IGRAPH_PARSEERROR); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 121| 0| } 122| | 123| 60.8k| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]); 124| | 125| 60.8k| if (dynamic_alloc) { ------------------ | Branch (125:9): [True: 217, False: 60.6k] ------------------ 126| 217| tmp = IGRAPH_CALLOC(length+1, char); ------------------ | | 32| 217|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 217, False: 0] | | ------------------ ------------------ 127| 217| IGRAPH_CHECK_OOM(tmp, "Failed to parse real number."); ------------------ | | 807| 217| do { \ | | 808| 217| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 217| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 217] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 217| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 128| 60.6k| } else { 129| 60.6k| tmp = buffer; 130| 60.6k| } 131| | 132| 60.8k| strncpy(tmp, str, length); 133| 60.8k| tmp[length]='\0'; 134| | 135| 60.8k| errno = 0; 136| 60.8k| *value = strtod(tmp, &end); 137| 60.8k| out_of_range = errno == ERANGE; /* This does not trigger when reading +-Inf. */ 138| 60.8k| last_char = *end; 139| | 140| | /* Free memory before raising any errors. */ 141| 60.8k| if (dynamic_alloc) { ------------------ | Branch (141:9): [True: 217, False: 60.6k] ------------------ 142| 217| IGRAPH_FREE(tmp); ------------------ | | 35| 217|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 143| 217| } 144| | 145| 60.8k| if (out_of_range) { ------------------ | Branch (145:9): [True: 25, False: 60.8k] ------------------ 146| 25| IGRAPH_ERROR("Failed to parse real number.", *value > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 493| 25| do { \ | | 494| 50| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (494:63): [True: 24, False: 1] | | ------------------ | | 495| 50| return igraph_errno ; \ | | ------------------ | | | Branch (495:16): [True: 24, False: 1] | | ------------------ | | 496| 25| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 147| 25| } 148| | 149| | /* Did we parse to the end of the string? */ 150| 60.8k| if (last_char) { ------------------ | Branch (150:9): [True: 0, False: 60.8k] ------------------ 151| 0| IGRAPH_ERRORF("Unexpected character '%c' while parsing real number.", IGRAPH_PARSEERROR, last_char); ------------------ | | 550| 0| do { \ | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | 553| 0| return igraph_errno; \ | | 554| 0| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 152| 0| } 153| | 154| 60.8k| return IGRAPH_SUCCESS; 155| 60.8k|}