igraph_gml_yylex:
1027| 3.37M|{
1028| 3.37M| yy_state_type yy_current_state;
1029| 3.37M| char *yy_cp, *yy_bp;
1030| 3.37M| int yy_act;
1031| 3.37M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1032| |
1033| 3.37M| yylval = yylval_param;
------------------
| | 837| 3.37M| # define yylval yyg->yylval_r
------------------
1034| |
1035| 3.37M| yylloc = yylloc_param;
------------------
| | 839| 3.37M| # define yylloc yyg->yylloc_r
------------------
1036| |
1037| 3.37M| if ( !yyg->yy_init )
------------------
| Branch (1037:7): [True: 3.34k, False: 3.37M]
------------------
1038| 3.34k| {
1039| 3.34k| yyg->yy_init = 1;
1040| |
1041| |#ifdef YY_USER_INIT
1042| | YY_USER_INIT;
1043| |#endif
1044| |
1045| 3.34k| if ( ! yyg->yy_start )
------------------
| Branch (1045:8): [True: 3.34k, False: 0]
------------------
1046| 3.34k| yyg->yy_start = 1; /* first start state */
1047| |
1048| 3.34k| if ( ! yyin )
------------------
| | 356| 3.34k|#define yyin yyg->yyin_r
------------------
| Branch (1048:8): [True: 0, False: 3.34k]
------------------
1049| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1050| |
1051| 3.34k| if ( ! yyout )
------------------
| | 357| 3.34k|#define yyout yyg->yyout_r
------------------
| Branch (1051:8): [True: 3.34k, False: 0]
------------------
1052| 3.34k| yyout = stdout;
------------------
| | 357| 3.34k|#define yyout yyg->yyout_r
------------------
1053| |
1054| 3.34k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.34k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.34k]
| | ------------------
| | 522| 3.34k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.34k| : NULL)
------------------
| Branch (1054:8): [True: 3.34k, False: 0]
------------------
1055| 3.34k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.34k|#define yyensure_buffer_stack igraph_gml_yyensure_buffer_stack
------------------
1056| 3.34k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1057| 3.34k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.34k|#define yy_create_buffer igraph_gml_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.34k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.34k|#define YY_BUF_SIZE 16384
------------------
1058| 3.34k| }
1059| |
1060| 3.34k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.34k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1061| 3.34k| }
1062| |
1063| 3.37M| {
1064| 3.37M|#line 80 "/src/igraph/src/io/gml-lexer.l"
1065| |
1066| |
1067| 3.37M|#line 1068 "/src/igraph/build/src/io/parsers/gml-lexer.c"
1068| |
1069| 8.99M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1069:23): [True: 8.99M, Folded]
------------------
1070| 8.99M| {
1071| 8.99M| yy_cp = yyg->yy_c_buf_p;
1072| |
1073| | /* Support of yytext. */
1074| 8.99M| *yy_cp = yyg->yy_hold_char;
1075| |
1076| | /* yy_bp points to the position in yy_ch_buf of the start of
1077| | * the current run.
1078| | */
1079| 8.99M| yy_bp = yy_cp;
1080| |
1081| 8.99M| yy_current_state = yyg->yy_start;
1082| 8.99M| yy_current_state += YY_AT_BOL();
------------------
| | 569| 8.99M|#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
| | ------------------
| | | | 527| 8.99M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1083| 9.02M|yy_match:
1084| 9.02M| do
1085| 210M| {
1086| 210M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 210M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1087| 210M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1087:9): [True: 40.0M, False: 170M]
------------------
1088| 40.0M| {
1089| 40.0M| yyg->yy_last_accepting_state = yy_current_state;
1090| 40.0M| yyg->yy_last_accepting_cpos = yy_cp;
1091| 40.0M| }
1092| 413M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1092:12): [True: 203M, False: 210M]
------------------
1093| 203M| {
1094| 203M| yy_current_state = (int) yy_def[yy_current_state];
1095| 203M| if ( yy_current_state >= 43 )
------------------
| Branch (1095:10): [True: 189M, False: 13.5M]
------------------
1096| 189M| yy_c = yy_meta[yy_c];
1097| 203M| }
1098| 210M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1099| 210M| ++yy_cp;
1100| 210M| }
1101| 210M| while ( yy_base[yy_current_state] != 85 );
------------------
| Branch (1101:11): [True: 201M, False: 9.02M]
------------------
1102| |
1103| 9.02M|yy_find_action:
1104| 9.02M| yy_act = yy_accept[yy_current_state];
1105| 9.02M| if ( yy_act == 0 )
------------------
| Branch (1105:8): [True: 7.89M, False: 1.13M]
------------------
1106| 7.89M| { /* have to back up */
1107| 7.89M| yy_cp = yyg->yy_last_accepting_cpos;
1108| 7.89M| yy_current_state = yyg->yy_last_accepting_state;
1109| 7.89M| yy_act = yy_accept[yy_current_state];
1110| 7.89M| }
1111| |
1112| 9.02M| YY_DO_BEFORE_ACTION;
------------------
| | 590| 9.02M| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 9.02M|#define yytext_ptr yytext_r
| | ------------------
| | 591| 9.02M| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 9.02M|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 9.02M| yyg->yy_hold_char = *yy_cp; \
| | 593| 9.02M| *yy_cp = '\0'; \
| | 594| 9.02M| yyg->yy_c_buf_p = yy_cp;
------------------
1113| |
1114| 9.02M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 18.0M|#define YY_END_OF_BUFFER 12
------------------
| Branch (1114:8): [True: 8.99M, False: 35.2k]
| Branch (1114:38): [True: 2.63M, False: 6.36M]
------------------
1115| 2.63M| {
1116| 2.63M| int yyl;
1117| 166M| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 166M|#define yyleng yyg->yyleng_r
------------------
| Branch (1117:19): [True: 164M, False: 2.63M]
------------------
1118| 164M| if ( yytext[yyl] == '\n' )
------------------
| | 360| 164M|#define yytext yyg->yytext_r
------------------
| Branch (1118:10): [True: 13.2M, False: 151M]
------------------
1119| |
1120| 13.2M| do{ yylineno++;
------------------
| | 361| 13.2M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 13.2M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1121| 13.2M| yycolumn=0;
------------------
| | 362| 13.2M|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 13.2M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1122| 13.2M| }while(0)
------------------
| Branch (1122:12): [Folded, False: 13.2M]
------------------
1123| 2.63M|;
1124| 2.63M| }
1125| |
1126| 9.03M|do_action: /* This label is used only to access EOF actions. */
1127| |
1128| 9.03M| switch ( yy_act )
1129| 9.03M| { /* beginning of action switch */
1130| 0| case 0: /* must back up */
------------------
| Branch (1130:4): [True: 0, False: 9.03M]
------------------
1131| | /* undo the effects of YY_DO_BEFORE_ACTION */
1132| 0| *yy_cp = yyg->yy_hold_char;
1133| 0| yy_cp = yyg->yy_last_accepting_cpos;
1134| 0| yy_current_state = yyg->yy_last_accepting_state;
1135| 0| goto yy_find_action;
1136| |
1137| 0|case 1:
------------------
| Branch (1137:1): [True: 0, False: 9.03M]
------------------
1138| 0|YY_RULE_SETUP
------------------
| | 1019| 0| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 0|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 0, False: 0]
| | ------------------
| | 1020| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 0| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 0|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 0|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 0| YY_USER_ACTION
| | ------------------
| | | | 764| 0|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1139| 0|#line 82 "/src/igraph/src/io/gml-lexer.l"
1140| 0|{ /* comments ignored */ }
1141| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1142| 370k|case 2:
------------------
| Branch (1142:1): [True: 370k, False: 8.66M]
------------------
1143| |/* rule 2 can match eol */
1144| 370k|YY_RULE_SETUP
------------------
| | 1019| 370k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 370k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 370k, False: 0]
| | ------------------
| | 1020| 370k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 370k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 370k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 370k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 370k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 370k| YY_USER_ACTION
| | ------------------
| | | | 764| 370k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 370k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 370k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 370k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1145| 370k|#line 84 "/src/igraph/src/io/gml-lexer.l"
1146| 370k|{ BEGIN(INITIAL); return STRING; }
------------------
| | 369| 370k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return STRING; }
------------------
| | 780| 370k|#define INITIAL 0
------------------
1147| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1148| 0|case 3:
------------------
| Branch (1148:1): [True: 0, False: 9.03M]
------------------
1149| 0|YY_RULE_SETUP
------------------
| | 1019| 0| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 0|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 0, False: 0]
| | ------------------
| | 1020| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 0| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 0|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 0|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 0| YY_USER_ACTION
| | ------------------
| | | | 764| 0|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1150| 0|#line 85 "/src/igraph/src/io/gml-lexer.l"
1151| 0|{ BEGIN(INITIAL); return NUM; }
------------------
| | 369| 0|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NUM; }
------------------
| | 780| 0|#define INITIAL 0
------------------
1152| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1153| 744k|case 4:
------------------
| Branch (1153:1): [True: 744k, False: 8.28M]
------------------
1154| 744k|YY_RULE_SETUP
------------------
| | 1019| 744k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 744k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 744k, False: 0]
| | ------------------
| | 1020| 744k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 744k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 744k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 744k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 744k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 744k| YY_USER_ACTION
| | ------------------
| | | | 764| 744k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 744k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 744k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 744k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1155| 744k|#line 86 "/src/igraph/src/io/gml-lexer.l"
1156| 744k|{ BEGIN(INITIAL); return NUM; }
------------------
| | 369| 744k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NUM; }
------------------
| | 780| 744k|#define INITIAL 0
------------------
1157| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1158| 1.49M|case 5:
------------------
| Branch (1158:1): [True: 1.49M, False: 7.53M]
------------------
1159| 1.49M|YY_RULE_SETUP
------------------
| | 1019| 1.49M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 1.49M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 1.49M, False: 0]
| | ------------------
| | 1020| 1.49M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 1.49M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 1.49M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 1.49M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 1.49M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 1.49M| YY_USER_ACTION
| | ------------------
| | | | 764| 1.49M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 1.49M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 1.49M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 1.49M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1160| 1.49M|#line 87 "/src/igraph/src/io/gml-lexer.l"
1161| 1.49M|{ BEGIN(VALUE); return KEYWORD; }
------------------
| | 369| 1.49M|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(VALUE); return KEYWORD; }
------------------
| | 781| 1.49M|#define VALUE 1
------------------
1162| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1163| 381k|case 6:
------------------
| Branch (1163:1): [True: 381k, False: 8.64M]
------------------
1164| 381k|YY_RULE_SETUP
------------------
| | 1019| 381k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 381k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 381k, False: 0]
| | ------------------
| | 1020| 381k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 381k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 381k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 381k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 381k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 381k| YY_USER_ACTION
| | ------------------
| | | | 764| 381k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 381k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 381k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 381k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1165| 381k|#line 88 "/src/igraph/src/io/gml-lexer.l"
1166| 381k|{
1167| 381k| BEGIN(INITIAL);
------------------
| | 369| 381k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
BEGIN(INITIAL);
------------------
| | 780| 381k|#define INITIAL 0
------------------
1168| 381k| yyextra->depth++;
------------------
| | 358| 381k|#define yyextra yyg->yyextra_r
------------------
1169| 381k| if (yyextra->depth >= 32) {
------------------
| | 358| 381k|#define yyextra yyg->yyextra_r
------------------
| Branch (1169:31): [True: 0, False: 381k]
------------------
1170| 0| return ERROR;
1171| 381k| } else {
1172| 381k| return LISTOPEN;
1173| 381k| }
1174| 381k| }
1175| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1176| 381k|case 7:
------------------
| Branch (1176:1): [True: 381k, False: 8.64M]
------------------
1177| 381k|YY_RULE_SETUP
------------------
| | 1019| 381k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 381k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 381k, False: 0]
| | ------------------
| | 1020| 381k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 381k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 381k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 381k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 381k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 381k| YY_USER_ACTION
| | ------------------
| | | | 764| 381k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 381k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 381k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 381k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1178| 381k|#line 97 "/src/igraph/src/io/gml-lexer.l"
1179| 381k|{
1180| 381k| yyextra->depth--;
------------------
| | 358| 381k|#define yyextra yyg->yyextra_r
------------------
1181| 381k| return LISTCLOSE;
1182| 381k| }
1183| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1184| 3.35M|case 8:
------------------
| Branch (1184:1): [True: 3.35M, False: 5.67M]
------------------
1185| 3.35M|YY_RULE_SETUP
------------------
| | 1019| 3.35M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 3.35M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 3.35M, False: 0]
| | ------------------
| | 1020| 3.35M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 3.35M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 3.35M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 3.35M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 3.35M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 3.35M| YY_USER_ACTION
| | ------------------
| | | | 764| 3.35M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 3.35M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 3.35M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 3.35M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1186| 3.35M|#line 101 "/src/igraph/src/io/gml-lexer.l"
1187| 3.35M|{ /* other whitespace ignored */ }
1188| 3.35M| YY_BREAK
------------------
| | 1015| 3.35M|#define YY_BREAK /*LINTED*/break;
------------------
1189| 2.26M|case 9:
------------------
| Branch (1189:1): [True: 2.26M, False: 6.77M]
------------------
1190| |/* rule 9 can match eol */
1191| 2.26M|YY_RULE_SETUP
------------------
| | 1019| 2.26M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 2.26M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 2.26M, False: 0]
| | ------------------
| | 1020| 2.26M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 2.26M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 2.26M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 2.26M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 2.26M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 2.26M| YY_USER_ACTION
| | ------------------
| | | | 764| 2.26M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 2.26M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 2.26M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 2.26M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1192| 2.26M|#line 102 "/src/igraph/src/io/gml-lexer.l"
1193| 2.26M|{ yy_set_bol(true); /* set "beginning of line" even after \r */ }
------------------
| | 561| 2.26M| { \
| | 562| 2.26M| if ( ! YY_CURRENT_BUFFER ){\
| | ------------------
| | | | 521| 2.26M|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | | | ------------------
| | | | | Branch (521:29): [True: 2.26M, False: 0]
| | | | ------------------
| | | | 522| 2.26M| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | | | 523| 2.26M| : NULL)
| | ------------------
| | | Branch (562:7): [True: 0, False: 2.26M]
| | ------------------
| | 563| 0| yyensure_buffer_stack (yyscanner); \
| | ------------------
| | | | 86| 0|#define yyensure_buffer_stack igraph_gml_yyensure_buffer_stack
| | ------------------
| | 564| 0| YY_CURRENT_BUFFER_LVALUE = \
| | ------------------
| | | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 565| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
| | ------------------
| | | | 20| 0|#define yy_create_buffer igraph_gml_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
| | ------------------
| | 566| 0| } \
| | 567| 2.26M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
| | ------------------
| | | | 527| 2.26M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 568| 2.26M| }
------------------
1194| 2.26M| YY_BREAK
------------------
| | 1015| 2.26M|#define YY_BREAK /*LINTED*/break;
------------------
1195| 0|case 10:
------------------
| Branch (1195:1): [True: 0, False: 9.03M]
------------------
1196| 0|YY_RULE_SETUP
------------------
| | 1019| 0| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 0|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 0, False: 0]
| | ------------------
| | 1020| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 0| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 0|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 0|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 0| YY_USER_ACTION
| | ------------------
| | | | 764| 0|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1197| 0|#line 104 "/src/igraph/src/io/gml-lexer.l"
1198| 0|{ return ERROR; }
1199| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1200| 0|case 11:
------------------
| Branch (1200:1): [True: 0, False: 9.03M]
------------------
1201| 0|YY_RULE_SETUP
------------------
| | 1019| 0| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 0|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 0, False: 0]
| | ------------------
| | 1020| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 0| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 0|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 0|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 0| YY_USER_ACTION
| | ------------------
| | | | 764| 0|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1202| 0|#line 105 "/src/igraph/src/io/gml-lexer.l"
1203| 0|YY_FATAL_ERROR( "flex scanner jammed" );
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1204| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1205| 0|#line 1206 "/src/igraph/build/src/io/parsers/gml-lexer.c"
1206| 3.34k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.34k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.34k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
| Branch (1206:1): [True: 3.34k, False: 9.02M]
------------------
1207| 3.34k|case YY_STATE_EOF(VALUE):
------------------
| | 377| 3.34k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.34k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
| Branch (1207:1): [True: 0, False: 9.03M]
------------------
1208| 3.34k| yyterminate();
------------------
| | 978| 3.34k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.34k|#define YY_NULL 0
| | ------------------
------------------
1209| |
1210| 35.2k| case YY_END_OF_BUFFER:
------------------
| | 596| 35.2k|#define YY_END_OF_BUFFER 12
------------------
| Branch (1210:2): [True: 35.2k, False: 8.99M]
------------------
1211| 35.2k| {
1212| | /* Amount of text matched not including the EOB char. */
1213| 35.2k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 35.2k|#define yytext_ptr yytext_r
------------------
1214| |
1215| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1216| 35.2k| *yy_cp = yyg->yy_hold_char;
1217| 35.2k| YY_RESTORE_YY_MORE_OFFSET
1218| |
1219| 35.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 35.2k|#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| 35.2k|#define YY_BUFFER_NEW 0
------------------
| Branch (1219:8): [True: 3.34k, False: 31.9k]
------------------
1220| 3.34k| {
1221| | /* We're scanning a new file or input source. It's
1222| | * possible that this happened because the user
1223| | * just pointed yyin at a new source and called
1224| | * yylex(). If so, then we have to assure
1225| | * consistency between YY_CURRENT_BUFFER and our
1226| | * globals. Here is the right place to do so, because
1227| | * this is the first action (other than possibly a
1228| | * back-up) that will match for the new input source.
1229| | */
1230| 3.34k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1231| 3.34k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.34k|#define yyin yyg->yyin_r
------------------
1232| 3.34k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.34k|#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.34k|#define YY_BUFFER_NORMAL 1
------------------
1233| 3.34k| }
1234| |
1235| | /* Note that here we test for yy_c_buf_p "<=" to the position
1236| | * of the first EOB in the buffer, since yy_c_buf_p will
1237| | * already have been incremented past the NUL character
1238| | * (since all states make transitions on EOB to the
1239| | * end-of-buffer state). Contrast this with the test
1240| | * in input().
1241| | */
1242| 35.2k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 35.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1242:8): [True: 0, False: 35.2k]
------------------
1243| 0| { /* This was really a NUL. */
1244| 0| yy_state_type yy_next_state;
1245| |
1246| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
1247| |
1248| 0| yy_current_state = yy_get_previous_state( yyscanner );
1249| |
1250| | /* Okay, we're now positioned to make the NUL
1251| | * transition. We couldn't have
1252| | * yy_get_previous_state() go ahead and do it
1253| | * for us because it doesn't know how to deal
1254| | * with the possibility of jamming (and we don't
1255| | * want to build jamming into it because then it
1256| | * will run more slowly).
1257| | */
1258| |
1259| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1260| |
1261| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 0|#define YY_MORE_ADJ 0
------------------
1262| |
1263| 0| if ( yy_next_state )
------------------
| Branch (1263:9): [True: 0, False: 0]
------------------
1264| 0| {
1265| | /* Consume the NUL. */
1266| 0| yy_cp = ++yyg->yy_c_buf_p;
1267| 0| yy_current_state = yy_next_state;
1268| 0| goto yy_match;
1269| 0| }
1270| |
1271| 0| else
1272| 0| {
1273| 0| yy_cp = yyg->yy_c_buf_p;
1274| 0| goto yy_find_action;
1275| 0| }
1276| 0| }
1277| |
1278| 35.2k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1278:17): [True: 35.2k, False: 0]
------------------
1279| 35.2k| {
1280| 3.34k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.34k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1280:4): [True: 3.34k, False: 31.9k]
------------------
1281| 3.34k| {
1282| 3.34k| yyg->yy_did_buffer_switch_on_eof = 0;
1283| |
1284| 3.34k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.34k|#define yywrap igraph_gml_yywrap
| | ------------------
| | | | 573| 3.34k|#define igraph_gml_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:38): [True: 3.34k, Folded]
| | | | ------------------
| | ------------------
------------------
1285| 3.34k| {
1286| | /* Note: because we've taken care in
1287| | * yy_get_next_buffer() to have set up
1288| | * yytext, we can now set up
1289| | * yy_c_buf_p so that if some total
1290| | * hoser (like flex itself) wants to
1291| | * call the scanner after we return the
1292| | * YY_NULL, it'll still work - another
1293| | * YY_NULL will get returned.
1294| | */
1295| 3.34k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.34k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 3.34k|#define YY_MORE_ADJ 0
------------------
1296| |
1297| 3.34k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.34k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.34k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
1298| 3.34k| goto do_action;
1299| 3.34k| }
1300| |
1301| 0| else
1302| 0| {
1303| 0| if ( ! yyg->yy_did_buffer_switch_on_eof )
------------------
| Branch (1303:11): [True: 0, False: 0]
------------------
1304| 0| YY_NEW_FILE;
------------------
| | 379| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner )
| | ------------------
| | | | 98| 0|#define yyrestart igraph_gml_yyrestart
| | ------------------
| | #define YY_NEW_FILE yyrestart( yyin , yyscanner )
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
------------------
1305| 0| }
1306| 0| break;
1307| 3.34k| }
1308| |
1309| 28.5k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 28.5k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1309:4): [True: 28.5k, False: 6.68k]
------------------
1310| 28.5k| yyg->yy_c_buf_p =
1311| 28.5k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 28.5k|#define yytext_ptr yytext_r
------------------
1312| |
1313| 28.5k| yy_current_state = yy_get_previous_state( yyscanner );
1314| |
1315| 28.5k| yy_cp = yyg->yy_c_buf_p;
1316| 28.5k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 28.5k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 28.5k|#define YY_MORE_ADJ 0
------------------
1317| 28.5k| goto yy_match;
1318| |
1319| 3.34k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 3.34k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1319:4): [True: 3.34k, False: 31.9k]
------------------
1320| 3.34k| yyg->yy_c_buf_p =
1321| 3.34k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 3.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1322| |
1323| 3.34k| yy_current_state = yy_get_previous_state( yyscanner );
1324| |
1325| 3.34k| yy_cp = yyg->yy_c_buf_p;
1326| 3.34k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.34k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 3.34k|#define YY_MORE_ADJ 0
------------------
1327| 3.34k| goto yy_find_action;
1328| 35.2k| }
1329| 0| break;
1330| 35.2k| }
1331| |
1332| 0| default:
------------------
| Branch (1332:2): [True: 0, False: 9.03M]
------------------
1333| 0| YY_FATAL_ERROR(
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1334| 9.03M| "fatal flex scanner internal error--no action found" );
1335| 9.03M| } /* end of action switch */
1336| 9.03M| } /* end of scanning one token */
1337| 3.37M| } /* end of user's declarations */
1338| 3.37M|} /* end of yylex */
igraph_gml_yyrestart:
1638| 3.34k|{
1639| 3.34k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1640| |
1641| 3.34k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.34k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.34k, False: 0]
| | ------------------
| | 522| 3.34k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.34k| : NULL)
------------------
| Branch (1641:7): [True: 0, False: 3.34k]
------------------
1642| 0| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 0|#define yyensure_buffer_stack igraph_gml_yyensure_buffer_stack
------------------
1643| 0| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1644| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 0|#define yy_create_buffer igraph_gml_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
------------------
1645| 0| }
1646| |
1647| 3.34k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.34k|#define yy_init_buffer igraph_gml_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.34k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.34k, False: 0]
| | ------------------
| | 522| 3.34k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.34k| : NULL)
------------------
1648| 3.34k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.34k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1649| 3.34k|}
igraph_gml_yy_create_buffer:
1703| 3.34k|{
1704| 3.34k| YY_BUFFER_STATE b;
1705| |
1706| 3.34k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.34k|#define yyalloc igraph_gml_yyalloc
------------------
1707| 3.34k| if ( ! b )
------------------
| Branch (1707:7): [True: 0, False: 3.34k]
------------------
1708| 3.34k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1709| |
1710| 3.34k| b->yy_buf_size = size;
1711| |
1712| | /* yy_ch_buf has to be 2 characters longer than the size given because
1713| | * we need to put in 2 end-of-buffer characters.
1714| | */
1715| 3.34k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.34k|#define yyalloc igraph_gml_yyalloc
------------------
1716| 3.34k| if ( ! b->yy_ch_buf )
------------------
| Branch (1716:7): [True: 0, False: 3.34k]
------------------
1717| 3.34k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1718| |
1719| 3.34k| b->yy_is_our_buffer = 1;
1720| |
1721| 3.34k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.34k|#define yy_init_buffer igraph_gml_yy_init_buffer
------------------
1722| |
1723| 3.34k| return b;
1724| 3.34k|}
igraph_gml_yy_delete_buffer:
1731| 3.34k|{
1732| 3.34k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1733| |
1734| 3.34k| if ( ! b )
------------------
| Branch (1734:7): [True: 0, False: 3.34k]
------------------
1735| 0| return;
1736| |
1737| 3.34k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.34k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.34k, False: 0]
| | ------------------
| | 522| 3.34k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.34k| : NULL)
------------------
| Branch (1737:7): [True: 3.34k, False: 0]
------------------
1738| 3.34k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1739| |
1740| 3.34k| if ( b->yy_is_our_buffer )
------------------
| Branch (1740:7): [True: 3.34k, False: 0]
------------------
1741| 3.34k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.34k|#define yyfree igraph_gml_yyfree
------------------
1742| |
1743| 3.34k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.34k|#define yyfree igraph_gml_yyfree
------------------
1744| 3.34k|}
igraph_gml_yy_flush_buffer:
1780| 6.68k|{
1781| 6.68k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1782| 6.68k| if ( ! b )
------------------
| Branch (1782:7): [True: 0, False: 6.68k]
------------------
1783| 0| return;
1784| |
1785| 6.68k| b->yy_n_chars = 0;
1786| |
1787| | /* We always need two end-of-buffer characters. The first causes
1788| | * a transition to the end-of-buffer state. The second causes
1789| | * a jam in that state.
1790| | */
1791| 6.68k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.68k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1792| 6.68k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.68k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1793| |
1794| 6.68k| b->yy_buf_pos = &b->yy_ch_buf[0];
1795| |
1796| 6.68k| b->yy_at_bol = 1;
1797| 6.68k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 6.68k|#define YY_BUFFER_NEW 0
------------------
1798| |
1799| 6.68k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 6.68k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.68k, False: 0]
| | ------------------
| | 522| 6.68k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.68k| : NULL)
------------------
| Branch (1799:7): [True: 3.34k, False: 3.34k]
------------------
1800| 3.34k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.34k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1801| 6.68k|}
igraph_gml_yypop_buffer_state:
1841| 3.34k|{
1842| 3.34k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1843| 3.34k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.34k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.34k, False: 0]
| | ------------------
| | 522| 3.34k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.34k| : NULL)
------------------
| Branch (1843:6): [True: 3.34k, False: 0]
------------------
1844| 3.34k| return;
1845| |
1846| 0| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
------------------
| | 26| 0|#define yy_delete_buffer igraph_gml_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)
------------------
1847| 0| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1848| 0| if (yyg->yy_buffer_stack_top > 0)
------------------
| Branch (1848:6): [True: 0, False: 0]
------------------
1849| 0| --yyg->yy_buffer_stack_top;
1850| |
1851| 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)
------------------
1852| 0| yy_load_buffer_state( yyscanner );
------------------
| | 62| 0|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1853| 0| yyg->yy_did_buffer_switch_on_eof = 1;
1854| 0| }
1855| 0|}
igraph_gml_yyget_leng:
2078| 2.61M|{
2079| 2.61M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2080| 2.61M| return yyleng;
------------------
| | 359| 2.61M|#define yyleng yyg->yyleng_r
------------------
2081| 2.61M|}
igraph_gml_yyget_text:
2088| 2.61M|{
2089| 2.61M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2090| 2.61M| return yytext;
------------------
| | 360| 2.61M|#define yytext yyg->yytext_r
------------------
2091| 2.61M|}
igraph_gml_yyset_extra:
2098| 6.68k|{
2099| 6.68k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2100| 6.68k| yyextra = user_defined ;
------------------
| | 358| 6.68k|#define yyextra yyg->yyextra_r
------------------
2101| 6.68k|}
igraph_gml_yyset_in:
2140| 3.34k|{
2141| 3.34k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2142| 3.34k| yyin = _in_str ;
------------------
| | 356| 3.34k|#define yyin yyg->yyin_r
------------------
2143| 3.34k|}
igraph_gml_yylex_init_extra:
2223| 3.34k|{
2224| 3.34k| struct yyguts_t dummy_yyguts;
2225| |
2226| 3.34k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.34k|#define yyset_extra igraph_gml_yyset_extra
------------------
2227| |
2228| 3.34k| if (ptr_yy_globals == NULL){
------------------
| Branch (2228:9): [True: 0, False: 3.34k]
------------------
2229| 0| errno = EINVAL;
2230| 0| return 1;
2231| 0| }
2232| |
2233| 3.34k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.34k|#define yyalloc igraph_gml_yyalloc
------------------
2234| |
2235| 3.34k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2235:9): [True: 0, False: 3.34k]
------------------
2236| 0| errno = ENOMEM;
2237| 0| return 1;
2238| 0| }
2239| |
2240| | /* By setting to 0xAA, we expose bugs in
2241| | yy_init_globals. Leave at 0x00 for releases. */
2242| 3.34k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2243| |
2244| 3.34k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.34k|#define yyset_extra igraph_gml_yyset_extra
------------------
2245| |
2246| 3.34k| return yy_init_globals ( *ptr_yy_globals );
2247| 3.34k|}
igraph_gml_yylex_destroy:
2284| 3.34k|{
2285| 3.34k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2286| |
2287| | /* Pop the buffer stack, destroying each element. */
2288| 6.68k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 6.68k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.34k, False: 3.34k]
| | | Branch (521:29): [True: 6.68k, False: 0]
| | ------------------
| | 522| 6.68k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.68k| : NULL)
------------------
2289| 3.34k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.34k|#define yy_delete_buffer igraph_gml_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.34k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.34k, False: 0]
| | ------------------
| | 522| 3.34k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.34k| : NULL)
------------------
2290| 3.34k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2291| 3.34k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.34k|#define yypop_buffer_state igraph_gml_yypop_buffer_state
------------------
2292| 3.34k| }
2293| |
2294| | /* Destroy the stack itself. */
2295| 3.34k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.34k|#define yyfree igraph_gml_yyfree
------------------
2296| 3.34k| yyg->yy_buffer_stack = NULL;
2297| |
2298| | /* Destroy the start condition stack. */
2299| 3.34k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.34k|#define yyfree igraph_gml_yyfree
------------------
2300| 3.34k| yyg->yy_start_stack = NULL;
2301| |
2302| | /* Reset the globals. This is important in a non-reentrant scanner so the next time
2303| | * yylex() is called, initialization will occur. */
2304| 3.34k| yy_init_globals( yyscanner);
2305| |
2306| | /* Destroy the main struct (reentrant only). */
2307| 3.34k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.34k|#define yyfree igraph_gml_yyfree
------------------
2308| | yyscanner = NULL;
2309| 3.34k| return 0;
2310| 3.34k|}
igraph_gml_yyalloc:
2340| 13.3k|{
2341| 13.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2342| 13.3k| (void)yyg;
2343| 13.3k| return malloc(size);
2344| 13.3k|}
igraph_gml_yyrealloc:
2347| 482|{
2348| 482| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2349| 482| (void)yyg;
2350| |
2351| | /* The cast to (char *) in the following accommodates both
2352| | * implementations that use char* generic pointers, and those
2353| | * that use void* generic pointers. It works with the latter
2354| | * because both ANSI C and C++ allow castless assignment from
2355| | * any pointer type to void*, and deal with argument conversions
2356| | * as though doing an assignment.
2357| | */
2358| 482| return realloc(ptr, size);
2359| 482|}
igraph_gml_yyfree:
2362| 16.7k|{
2363| 16.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2364| 16.7k| (void)yyg;
2365| 16.7k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2366| 16.7k|}
gml-lexer.c:yy_get_next_buffer:
1348| 35.2k|{
1349| 35.2k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1350| 35.2k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 35.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1351| 35.2k| char *source = yyg->yytext_ptr;
------------------
| | 579| 35.2k|#define yytext_ptr yytext_r
------------------
1352| 35.2k| int number_to_move, i;
1353| 35.2k| int ret_val;
1354| |
1355| 35.2k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 35.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1355:7): [True: 0, False: 35.2k]
------------------
1356| 35.2k| YY_FATAL_ERROR(
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1357| 35.2k| "fatal flex scanner internal error--end of buffer missed" );
1358| |
1359| 35.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 35.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1359:7): [True: 0, False: 35.2k]
------------------
1360| 0| { /* Don't try to fill the buffer, so this is an EOF. */
1361| 0| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
------------------
| | 712| 0|#define YY_MORE_ADJ 0
------------------
| Branch (1361:8): [True: 0, False: 0]
------------------
1362| 0| {
1363| | /* We matched a single character, the EOB, so
1364| | * treat this as a final EOF.
1365| | */
1366| 0| return EOB_ACT_END_OF_FILE;
------------------
| | 410| 0|#define EOB_ACT_END_OF_FILE 1
------------------
1367| 0| }
1368| |
1369| 0| else
1370| 0| {
1371| | /* We matched some text prior to the EOB, first
1372| | * process it.
1373| | */
1374| 0| return EOB_ACT_LAST_MATCH;
------------------
| | 411| 0|#define EOB_ACT_LAST_MATCH 2
------------------
1375| 0| }
1376| 0| }
1377| |
1378| | /* Try to read more data. */
1379| |
1380| | /* First move last chars to start of buffer. */
1381| 35.2k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 35.2k|#define yytext_ptr yytext_r
------------------
1382| |
1383| 1.95G| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1383:15): [True: 1.95G, False: 35.2k]
------------------
1384| 1.95G| *(dest++) = *(source++);
1385| |
1386| 35.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 35.2k|#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| 35.2k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1386:7): [True: 3.34k, False: 31.9k]
------------------
1387| | /* don't do the read, it's not guaranteed to return an EOF,
1388| | * just force an EOF
1389| | */
1390| 3.34k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 3.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1391| |
1392| 31.9k| else
1393| 31.9k| {
1394| 31.9k| int num_to_read =
1395| 31.9k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 31.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1396| |
1397| 32.4k| while ( num_to_read <= 0 )
------------------
| Branch (1397:11): [True: 482, False: 31.9k]
------------------
1398| 482| { /* Not enough room in the buffer - grow it. */
1399| |
1400| | /* just a shorter name for the current buffer */
1401| 482| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 482|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1402| |
1403| 482| int yy_c_buf_p_offset =
1404| 482| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1405| |
1406| 482| if ( b->yy_is_our_buffer )
------------------
| Branch (1406:9): [True: 482, False: 0]
------------------
1407| 482| {
1408| 482| int new_size = b->yy_buf_size * 2;
1409| |
1410| 482| if ( new_size <= 0 )
------------------
| Branch (1410:10): [True: 0, False: 482]
------------------
1411| 0| b->yy_buf_size += b->yy_buf_size / 8;
1412| 482| else
1413| 482| b->yy_buf_size *= 2;
1414| |
1415| 482| b->yy_ch_buf = (char *)
1416| | /* Include room in for 2 EOB chars. */
1417| 482| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 482|#define yyrealloc igraph_gml_yyrealloc
------------------
1418| 482| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1419| 482| }
1420| 0| else
1421| | /* Can't grow it, we don't own it. */
1422| 0| b->yy_ch_buf = NULL;
1423| |
1424| 482| if ( ! b->yy_ch_buf )
------------------
| Branch (1424:9): [True: 0, False: 482]
------------------
1425| 482| YY_FATAL_ERROR(
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1426| 482| "fatal error - scanner input buffer overflow" );
1427| |
1428| 482| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1429| |
1430| 482| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 482|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1431| 482| number_to_move - 1;
1432| |
1433| 482| }
1434| |
1435| 31.9k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 925| 31.9k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1435:8): [True: 29.7k, False: 2.21k]
------------------
1436| 29.7k| num_to_read = YY_READ_BUF_SIZE;
------------------
| | 925| 29.7k|#define YY_READ_BUF_SIZE 8192
------------------
1437| |
1438| | /* Read in more data. */
1439| 31.9k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 942| 31.9k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 31.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (942:7): [True: 0, False: 31.9k]
| | ------------------
| | 943| 31.9k| { \
| | 944| 0| int c = '*'; \
| | 945| 0| int n; \
| | 946| 0| for ( n = 0; n < max_size && \
| | ------------------
| | | Branch (946:16): [True: 0, False: 0]
| | ------------------
| | 947| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (947:9): [True: 0, False: 0]
| | | Branch (947:38): [True: 0, False: 0]
| | ------------------
| | 948| 0| buf[n] = (char) c; \
| | 949| 0| if ( c == '\n' ) \
| | ------------------
| | | Branch (949:8): [True: 0, False: 0]
| | ------------------
| | 950| 0| buf[n++] = (char) c; \
| | 951| 0| if ( c == EOF && ferror( yyin ) ) \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (951:8): [True: 0, False: 0]
| | | Branch (951:20): [True: 0, False: 0]
| | ------------------
| | 952| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \
| | ------------------
| | | | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | | | ------------------
| | | | | | 895| 0| do { \
| | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | | | 897| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (897:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 953| 0| result = n; \
| | 954| 0| } \
| | 955| 31.9k| else \
| | 956| 31.9k| { \
| | 957| 31.9k| errno=0; \
| | 958| 31.9k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 31.9k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.34k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (958:11): [True: 3.34k, False: 28.5k]
| | | Branch (958:78): [True: 0, False: 3.34k]
| | ------------------
| | 959| 31.9k| { \
| | 960| 0| if( errno != EINTR) \
| | ------------------
| | | Branch (960:8): [True: 0, False: 0]
| | ------------------
| | 961| 0| { \
| | 962| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \
| | ------------------
| | | | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | | | ------------------
| | | | | | 895| 0| do { \
| | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | | | 897| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (897:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 963| 0| break; \
| | 964| 0| } \
| | 965| 0| errno=0; \
| | 966| 0| clearerr(yyin); \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | 967| 0| } \
| | 968| 31.9k| }\
------------------
1440| 31.9k| yyg->yy_n_chars, num_to_read );
1441| |
1442| 31.9k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 31.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1443| 31.9k| }
1444| |
1445| 35.2k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1445:7): [True: 6.68k, False: 28.5k]
------------------
1446| 6.68k| {
1447| 6.68k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 712| 6.68k|#define YY_MORE_ADJ 0
------------------
| Branch (1447:8): [True: 3.34k, False: 3.34k]
------------------
1448| 3.34k| {
1449| 3.34k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.34k|#define EOB_ACT_END_OF_FILE 1
------------------
1450| 3.34k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.34k|#define yyrestart igraph_gml_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.34k|#define yyin yyg->yyin_r
------------------
1451| 3.34k| }
1452| |
1453| 3.34k| else
1454| 3.34k| {
1455| 3.34k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 3.34k|#define EOB_ACT_LAST_MATCH 2
------------------
1456| 3.34k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 3.34k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1457| 3.34k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 3.34k|#define YY_BUFFER_EOF_PENDING 2
------------------
1458| 3.34k| }
1459| 6.68k| }
1460| |
1461| 28.5k| else
1462| 28.5k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 28.5k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1463| |
1464| 35.2k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 35.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1464:6): [True: 0, False: 35.2k]
------------------
1465| | /* Extend the array by 50%, plus the number we really need. */
1466| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1467| 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_gml_yyrealloc
------------------
1468| 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]
------------------
1469| 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 (1469:8): [True: 0, False: 0]
------------------
1470| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1471| | /* "- 2" to take care of EOB's */
1472| 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]
------------------
1473| 0| }
1474| |
1475| 35.2k| yyg->yy_n_chars += number_to_move;
1476| 35.2k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 35.2k|#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| 35.2k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1477| 35.2k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 35.2k|#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| 35.2k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1478| |
1479| 35.2k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 35.2k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 35.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1480| |
1481| 35.2k| return ret_val;
1482| 35.2k|}
gml-lexer.c:yy_get_previous_state:
1487| 31.9k|{
1488| 31.9k| yy_state_type yy_current_state;
1489| 31.9k| char *yy_cp;
1490| 31.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1491| |
1492| 31.9k| yy_current_state = yyg->yy_start;
1493| 31.9k| yy_current_state += YY_AT_BOL();
------------------
| | 569| 31.9k|#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
| | ------------------
| | | | 527| 31.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1494| |
1495| 1.95G| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 579| 31.9k|#define yytext_ptr yytext_r
------------------
for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 712| 31.9k|#define YY_MORE_ADJ 0
------------------
| Branch (1495:47): [True: 1.95G, False: 31.9k]
------------------
1496| 1.95G| {
1497| 1.95G| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 23);
------------------
| | 346| 1.95G|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1497:19): [True: 1.95G, False: 0]
------------------
1498| 1.95G| if ( yy_accept[yy_current_state] )
------------------
| Branch (1498:8): [True: 159M, False: 1.79G]
------------------
1499| 159M| {
1500| 159M| yyg->yy_last_accepting_state = yy_current_state;
1501| 159M| yyg->yy_last_accepting_cpos = yy_cp;
1502| 159M| }
1503| 3.91G| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1503:11): [True: 1.95G, False: 1.95G]
------------------
1504| 1.95G| {
1505| 1.95G| yy_current_state = (int) yy_def[yy_current_state];
1506| 1.95G| if ( yy_current_state >= 43 )
------------------
| Branch (1506:9): [True: 1.95G, False: 21.4k]
------------------
1507| 1.95G| yy_c = yy_meta[yy_c];
1508| 1.95G| }
1509| 1.95G| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1510| 1.95G| }
1511| |
1512| 31.9k| return yy_current_state;
1513| 31.9k|}
gml-lexer.c:igraph_gml_yy_load_buffer_state:
1688| 10.0k|{
1689| 10.0k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1690| 10.0k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 10.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1691| 10.0k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 10.0k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 10.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1692| 10.0k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 10.0k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 10.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1693| 10.0k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1694| 10.0k|}
gml-lexer.c:igraph_gml_yy_init_buffer:
1752| 6.68k|{
1753| 6.68k| int oerrno = errno;
1754| 6.68k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1755| |
1756| 6.68k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 6.68k|#define yy_flush_buffer igraph_gml_yy_flush_buffer
------------------
1757| |
1758| 6.68k| b->yy_input_file = file;
1759| 6.68k| b->yy_fill_buffer = 1;
1760| |
1761| | /* If b is the current buffer, then yy_init_buffer was _probably_
1762| | * called from yyrestart() or through yy_get_next_buffer.
1763| | * In that case, we don't want to reset the lineno or column.
1764| | */
1765| 6.68k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 6.68k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.68k, False: 0]
| | ------------------
| | 522| 6.68k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.68k| : NULL)
------------------
| Branch (1765:9): [True: 3.34k, False: 3.34k]
------------------
1766| 3.34k| b->yy_bs_lineno = 1;
1767| 3.34k| b->yy_bs_column = 0;
1768| 3.34k| }
1769| |
1770| 6.68k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1770:32): [True: 6.68k, False: 0]
------------------
1771| |
1772| | errno = oerrno;
1773| 6.68k|}
gml-lexer.c:igraph_gml_yyensure_buffer_stack:
1861| 3.34k|{
1862| 3.34k| yy_size_t num_to_alloc;
1863| 3.34k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1864| |
1865| 3.34k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1865:6): [True: 3.34k, False: 0]
------------------
1866| |
1867| | /* First allocation is just for 2 elements, since we don't know if this
1868| | * scanner will even need a stack. We use 2 instead of 1 to avoid an
1869| | * immediate realloc on the next call.
1870| | */
1871| 3.34k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1872| 3.34k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.34k|#define yyalloc igraph_gml_yyalloc
------------------
1873| 3.34k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1874| 3.34k| , yyscanner);
1875| 3.34k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1875:8): [True: 0, False: 3.34k]
------------------
1876| 3.34k| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1877| |
1878| 3.34k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1879| |
1880| 3.34k| yyg->yy_buffer_stack_max = num_to_alloc;
1881| 3.34k| yyg->yy_buffer_stack_top = 0;
1882| 3.34k| return;
1883| 3.34k| }
1884| |
1885| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
------------------
| Branch (1885:6): [True: 0, False: 0]
------------------
1886| |
1887| | /* Increase the buffer to prepare for a possible push. */
1888| 0| yy_size_t grow_size = 8 /* arbitrary grow size */;
1889| |
1890| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1891| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
------------------
| | 242| 0|#define yyrealloc igraph_gml_yyrealloc
------------------
1892| 0| (yyg->yy_buffer_stack,
1893| 0| num_to_alloc * sizeof(struct yy_buffer_state*)
1894| 0| , yyscanner);
1895| 0| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1895:8): [True: 0, False: 0]
------------------
1896| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
------------------
| | 765| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1897| |
1898| | /* zero only the new slots.*/
1899| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1900| 0| yyg->yy_buffer_stack_max = num_to_alloc;
1901| 0| }
1902| 0|}
gml-lexer.c:yy_init_globals:
2250| 6.68k|{
2251| 6.68k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2252| | /* Initialization is the same as for the non-reentrant scanner.
2253| | * This function is called from yylex_destroy(), so don't allocate here.
2254| | */
2255| |
2256| 6.68k| yyg->yy_buffer_stack = NULL;
2257| 6.68k| yyg->yy_buffer_stack_top = 0;
2258| 6.68k| yyg->yy_buffer_stack_max = 0;
2259| 6.68k| yyg->yy_c_buf_p = NULL;
2260| 6.68k| yyg->yy_init = 0;
2261| 6.68k| yyg->yy_start = 0;
2262| |
2263| 6.68k| yyg->yy_start_stack_ptr = 0;
2264| 6.68k| yyg->yy_start_stack_depth = 0;
2265| 6.68k| yyg->yy_start_stack = NULL;
2266| |
2267| |/* Defined in main.c */
2268| |#ifdef YY_STDINIT
2269| | yyin = stdin;
2270| | yyout = stdout;
2271| |#else
2272| 6.68k| yyin = NULL;
------------------
| | 356| 6.68k|#define yyin yyg->yyin_r
------------------
2273| 6.68k| yyout = NULL;
------------------
| | 357| 6.68k|#define yyout yyg->yyout_r
------------------
2274| 6.68k|#endif
2275| |
2276| | /* For future reference: Set errno on error, since we are called by
2277| | * yylex_init()
2278| | */
2279| 6.68k| return 0;
2280| 6.68k|}
igraph_gml_yyparse:
1239| 3.34k|{
1240| |/* The lookahead symbol. */
1241| 3.34k|int yychar;
1242| |
1243| |
1244| |/* The semantic value of the lookahead symbol. */
1245| |/* Default value used for initialization, for pacifying older GCCs
1246| | or non-GCC compilers. */
1247| 3.34k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 380| 3.34k|# define YY_INITIAL_VALUE(Value) Value
------------------
1248| 3.34k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 380| 3.34k|# define YY_INITIAL_VALUE(Value) Value
------------------
1249| |
1250| |/* Location data for the lookahead symbol. */
1251| 3.34k|static YYLTYPE yyloc_default
1252| 3.34k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1253| 3.34k| = { 1, 1, 1, 1 }
1254| 3.34k|# endif
1255| 3.34k|;
1256| 3.34k|YYLTYPE yylloc = yyloc_default;
1257| |
1258| | /* Number of syntax errors so far. */
1259| 3.34k| int yynerrs;
1260| |
1261| 3.34k| yy_state_fast_t yystate;
1262| | /* Number of tokens to shift before error messages enabled. */
1263| 3.34k| int yyerrstatus;
1264| |
1265| | /* The stacks and their tools:
1266| | 'yyss': related to states.
1267| | 'yyvs': related to semantic values.
1268| | 'yyls': related to locations.
1269| |
1270| | Refer to the stacks through separate pointers, to allow yyoverflow
1271| | to reallocate them elsewhere. */
1272| |
1273| | /* The state stack. */
1274| 3.34k| yy_state_t yyssa[YYINITDEPTH];
1275| 3.34k| yy_state_t *yyss;
1276| 3.34k| yy_state_t *yyssp;
1277| |
1278| | /* The semantic value stack. */
1279| 3.34k| YYSTYPE yyvsa[YYINITDEPTH];
1280| 3.34k| YYSTYPE *yyvs;
1281| 3.34k| YYSTYPE *yyvsp;
1282| |
1283| | /* The location stack. */
1284| 3.34k| YYLTYPE yylsa[YYINITDEPTH];
1285| 3.34k| YYLTYPE *yyls;
1286| 3.34k| YYLTYPE *yylsp;
1287| |
1288| | /* The locations where the error started and ended. */
1289| 3.34k| YYLTYPE yyerror_range[3];
1290| |
1291| 3.34k| YYPTRDIFF_T yystacksize;
------------------
| | 295| 3.34k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1292| |
1293| 3.34k| int yyn;
1294| 3.34k| int yyresult;
1295| | /* Lookahead token as an internal (translated) token number. */
1296| 3.34k| int yytoken = 0;
1297| | /* The variables used to return semantic value and location from the
1298| | action routines. */
1299| 3.34k| YYSTYPE yyval;
1300| 3.34k| YYLTYPE yyloc;
1301| |
1302| 3.34k|#if YYERROR_VERBOSE
1303| | /* Buffer for error messages, and its allocated size. */
1304| 3.34k| char yymsgbuf[128];
1305| 3.34k| char *yymsg = yymsgbuf;
1306| 3.34k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 295| 3.34k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1307| 3.34k|#endif
1308| |
1309| 3.34k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1310| |
1311| | /* The number of symbols on the RHS of the reduced rule.
1312| | Keep to zero when no symbol should be popped. */
1313| 3.34k| int yylen = 0;
1314| |
1315| 3.34k| yyssp = yyss = yyssa;
1316| 3.34k| yyvsp = yyvs = yyvsa;
1317| 3.34k| yylsp = yyls = yylsa;
1318| 3.34k| yystacksize = YYINITDEPTH;
------------------
| | 936| 3.34k|# define YYINITDEPTH 200
------------------
1319| |
1320| 3.34k| YYDPRINTF ((stderr, "Starting parse\n"));
1321| |
1322| 3.34k| yystate = 0;
1323| 3.34k| yyerrstatus = 0;
1324| 3.34k| yynerrs = 0;
------------------
| | 71| 3.34k|#define yynerrs igraph_gml_yynerrs
------------------
1325| 3.34k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 700| 3.34k|#define YYEMPTY (-2)
------------------
1326| 3.34k| yylsp[0] = yylloc;
1327| 3.34k| goto yysetstate;
1328| |
1329| |
1330| |/*------------------------------------------------------------.
1331| || yynewstate -- push a new state, which is found in yystate. |
1332| |`------------------------------------------------------------*/
1333| 8.98M|yynewstate:
1334| | /* In all cases, when you get here, the value and location stacks
1335| | have just been pushed. So pushing a state here evens the stacks. */
1336| 8.98M| yyssp++;
1337| |
1338| |
1339| |/*--------------------------------------------------------------------.
1340| || yysetstate -- set current state (the top of the stack) to yystate. |
1341| |`--------------------------------------------------------------------*/
1342| 8.98M|yysetstate:
1343| 8.98M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1344| 8.98M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 403| 8.98M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (403:31): [Folded, False: 8.98M]
| | | Branch (403:37): [True: 0, False: 0]
| | | Branch (403:37): [True: 0, False: 0]
| | ------------------
------------------
1345| 8.98M| YY_IGNORE_USELESS_CAST_BEGIN
1346| 8.98M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 143| 8.98M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1347| 8.98M| YY_IGNORE_USELESS_CAST_END
1348| |
1349| 8.98M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1349:7): [True: 0, False: 8.98M]
------------------
1350| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1351| | goto yyexhaustedlab;
1352| |#else
1353| 0| {
1354| | /* Get the current used size of the three stacks, in elements. */
1355| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1;
------------------
| | 295| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1356| |
1357| |# if defined yyoverflow
1358| | {
1359| | /* Give user a chance to reallocate the stack. Use copies of
1360| | these so that the &'s don't force the real ones into
1361| | memory. */
1362| | yy_state_t *yyss1 = yyss;
1363| | YYSTYPE *yyvs1 = yyvs;
1364| | YYLTYPE *yyls1 = yyls;
1365| |
1366| | /* Each stack pointer address is followed by the size of the
1367| | data in use in that stack, in bytes. This used to be a
1368| | conditional around just the two extra args, but that might
1369| | be undefined if yyoverflow is a macro. */
1370| | yyoverflow (YY_("memory exhausted"),
1371| | &yyss1, yysize * YYSIZEOF (*yyssp),
1372| | &yyvs1, yysize * YYSIZEOF (*yyvsp),
1373| | &yyls1, yysize * YYSIZEOF (*yylsp),
1374| | &yystacksize);
1375| | yyss = yyss1;
1376| | yyvs = yyvs1;
1377| | yyls = yyls1;
1378| | }
1379| |# else /* defined YYSTACK_RELOCATE */
1380| | /* Extend the stack our own way. */
1381| 0| if (YYMAXDEPTH <= yystacksize)
------------------
| | 947| 0|# define YYMAXDEPTH 10000
------------------
| Branch (1381:11): [True: 0, False: 0]
------------------
1382| 0| goto yyexhaustedlab;
1383| 0| yystacksize *= 2;
1384| 0| if (YYMAXDEPTH < yystacksize)
------------------
| | 947| 0|# define YYMAXDEPTH 10000
------------------
| Branch (1384:11): [True: 0, False: 0]
------------------
1385| 0| yystacksize = YYMAXDEPTH;
------------------
| | 947| 0|# define YYMAXDEPTH 10000
------------------
1386| |
1387| 0| {
1388| 0| yy_state_t *yyss1 = yyss;
1389| 0| union yyalloc *yyptr =
1390| 0| YY_CAST (union yyalloc *,
------------------
| | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1391| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1392| 0| if (! yyptr)
------------------
| Branch (1392:13): [True: 0, False: 0]
------------------
1393| 0| goto yyexhaustedlab;
1394| 0| YYSTACK_RELOCATE (yyss_alloc, yyss);
------------------
| | 504| 0| do \
| | 505| 0| { \
| | 506| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 295| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 507| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 522| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 508| 0| Stack = &yyptr->Stack_alloc; \
| | 509| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 487| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 510| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 511| 0| } \
| | 512| 0| while (0)
| | ------------------
| | | Branch (512:12): [Folded, False: 0]
| | ------------------
------------------
1395| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs);
------------------
| | 504| 0| do \
| | 505| 0| { \
| | 506| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 295| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 507| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 522| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 508| 0| Stack = &yyptr->Stack_alloc; \
| | 509| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 487| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 510| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 511| 0| } \
| | 512| 0| while (0)
| | ------------------
| | | Branch (512:12): [Folded, False: 0]
| | ------------------
------------------
1396| 0| YYSTACK_RELOCATE (yyls_alloc, yyls);
------------------
| | 504| 0| do \
| | 505| 0| { \
| | 506| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 295| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 507| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 522| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 508| 0| Stack = &yyptr->Stack_alloc; \
| | 509| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 487| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 510| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 328| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 511| 0| } \
| | 512| 0| while (0)
| | ------------------
| | | Branch (512:12): [Folded, False: 0]
| | ------------------
------------------
1397| 0|# undef YYSTACK_RELOCATE
1398| 0| if (yyss1 != yyssa)
------------------
| Branch (1398:13): [True: 0, False: 0]
------------------
1399| 0| YYSTACK_FREE (yyss1);
------------------
| | 445| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 464| 0|# define YYFREE free
| | ------------------
------------------
1400| 0| }
1401| 0|# endif
1402| |
1403| 0| yyssp = yyss + yysize - 1;
1404| 0| yyvsp = yyvs + yysize - 1;
1405| 0| yylsp = yyls + yysize - 1;
1406| |
1407| 0| YY_IGNORE_USELESS_CAST_BEGIN
1408| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1409| 0| YY_CAST (long, yystacksize)));
1410| 0| YY_IGNORE_USELESS_CAST_END
1411| |
1412| 0| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1412:11): [True: 0, False: 0]
------------------
1413| 0| YYABORT;
------------------
| | 704| 0|#define YYABORT goto yyabortlab
------------------
1414| 0| }
1415| 8.98M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1416| |
1417| 8.98M| if (yystate == YYFINAL)
------------------
| | 537| 8.98M|#define YYFINAL 6
------------------
| Branch (1417:7): [True: 3.34k, False: 8.98M]
------------------
1418| 3.34k| YYACCEPT;
------------------
| | 703| 3.34k|#define YYACCEPT goto yyacceptlab
------------------
1419| |
1420| 8.98M| goto yybackup;
1421| |
1422| |
1423| |/*-----------.
1424| || yybackup. |
1425| |`-----------*/
1426| 8.98M|yybackup:
1427| | /* Do appropriate processing given the current state. Read a
1428| | lookahead token if we need one and don't already have one. */
1429| |
1430| | /* First try to decide what to do without reference to lookahead token. */
1431| 8.98M| yyn = yypact[yystate];
1432| 8.98M| if (yypact_value_is_default (yyn))
------------------
| | 624| 8.98M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 621| 8.98M|#define YYPACT_NINF (-4)
| | ------------------
| | | Branch (624:3): [True: 5.60M, False: 3.38M]
| | ------------------
------------------
1433| 5.60M| goto yydefault;
1434| |
1435| | /* Not known => get a lookahead token if don't already have one. */
1436| |
1437| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1438| 3.38M| if (yychar == YYEMPTY)
------------------
| | 700| 3.38M|#define YYEMPTY (-2)
------------------
| Branch (1438:7): [True: 3.37M, False: 3.34k]
------------------
1439| 3.37M| {
1440| 3.37M| YYDPRINTF ((stderr, "Reading a token: "));
1441| 3.37M| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 3.37M|#define yylex igraph_gml_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 133| 3.37M|#define scanner context->scanner
------------------
1442| 3.37M| }
1443| |
1444| 3.38M| if (yychar <= YYEOF)
------------------
| | 701| 3.38M|#define YYEOF 0
------------------
| Branch (1444:7): [True: 6.68k, False: 3.37M]
------------------
1445| 6.68k| {
1446| 6.68k| yychar = yytoken = YYEOF;
------------------
| | 701| 6.68k|#define YYEOF 0
------------------
1447| 6.68k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1448| 6.68k| }
1449| 3.37M| else
1450| 3.37M| {
1451| 3.37M| yytoken = YYTRANSLATE (yychar);
------------------
| | 557| 3.37M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 551| 3.37M|#define YYMAXUTOK 263
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 550| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (557:4): [True: 3.37M, False: 0]
| | | Branch (557:18): [True: 3.37M, False: 0]
| | ------------------
------------------
1452| 3.37M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1453| 3.37M| }
1454| |
1455| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1456| | detect an error, take that action. */
1457| 3.38M| yyn += yytoken;
1458| 3.38M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 539| 3.38M|#define YYLAST 10
------------------
| Branch (1458:7): [True: 0, False: 3.38M]
| Branch (1458:18): [True: 0, False: 3.38M]
| Branch (1458:34): [True: 3.34k, False: 3.37M]
------------------
1459| 3.34k| goto yydefault;
1460| 3.37M| yyn = yytable[yyn];
1461| 3.37M| if (yyn <= 0)
------------------
| Branch (1461:7): [True: 0, False: 3.37M]
------------------
1462| 0| {
1463| 0| if (yytable_value_is_error (yyn))
------------------
| | 629| 0| 0
| | ------------------
| | | Branch (629:3): [Folded, False: 0]
| | ------------------
------------------
1464| 0| goto yyerrlab;
1465| 0| yyn = -yyn;
1466| 0| goto yyreduce;
1467| 0| }
1468| |
1469| | /* Count tokens shifted since error; after three, turn off error
1470| | status. */
1471| 3.37M| if (yyerrstatus)
------------------
| Branch (1471:7): [True: 0, False: 3.37M]
------------------
1472| 0| yyerrstatus--;
1473| |
1474| | /* Shift the lookahead token. */
1475| 3.37M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1476| 3.37M| yystate = yyn;
1477| 3.37M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1478| 3.37M| *++yyvsp = yylval;
1479| 3.37M| YY_IGNORE_MAYBE_UNINITIALIZED_END
1480| 3.37M| *++yylsp = yylloc;
1481| |
1482| | /* Discard the shifted token. */
1483| 3.37M| yychar = YYEMPTY;
------------------
| | 700| 3.37M|#define YYEMPTY (-2)
------------------
1484| 3.37M| goto yynewstate;
1485| |
1486| |
1487| |/*-----------------------------------------------------------.
1488| || yydefault -- do the default action for the current state. |
1489| |`-----------------------------------------------------------*/
1490| 5.60M|yydefault:
1491| 5.60M| yyn = yydefact[yystate];
1492| 5.60M| if (yyn == 0)
------------------
| Branch (1492:7): [True: 0, False: 5.60M]
------------------
1493| 0| goto yyerrlab;
1494| 5.60M| goto yyreduce;
1495| |
1496| |
1497| |/*-----------------------------.
1498| || yyreduce -- do a reduction. |
1499| |`-----------------------------*/
1500| 5.60M|yyreduce:
1501| | /* yyn is the number of a rule to reduce with. */
1502| 5.60M| yylen = yyr2[yyn];
1503| |
1504| | /* If YYLEN is nonzero, implement the default value of the action:
1505| | '$$ = $1'.
1506| |
1507| | Otherwise, the following line sets YYVAL to garbage.
1508| | This behavior is undocumented and Bison
1509| | users should not rely upon it. Assigning to YYVAL
1510| | unconditionally makes the parser a bit smaller, and it avoids a
1511| | GCC warning that YYVAL may be used uninitialized. */
1512| 5.60M| yyval = yyvsp[1-yylen];
1513| |
1514| | /* Default location. */
1515| 5.60M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 738| 5.60M| do \
| | 739| 5.60M| if (N) \
| | ------------------
| | | Branch (739:11): [True: 5.60M, False: 0]
| | ------------------
| | 740| 5.60M| { \
| | 741| 5.60M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 756| 5.60M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 742| 5.60M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 756| 5.60M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 743| 5.60M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 756| 5.60M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 744| 5.60M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 756| 5.60M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 745| 5.60M| } \
| | 746| 5.60M| else \
| | 747| 5.60M| { \
| | 748| 0| (Current).first_line = (Current).last_line = \
| | 749| 0| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 756| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 750| 0| (Current).first_column = (Current).last_column = \
| | 751| 0| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 756| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 752| 0| } \
| | 753| 5.60M| while (0)
| | ------------------
| | | Branch (753:12): [Folded, False: 5.60M]
| | ------------------
------------------
1516| 5.60M| yyerror_range[1] = yyloc;
1517| 5.60M| YY_REDUCE_PRINT (yyn);
1518| 5.60M| switch (yyn)
1519| 5.60M| {
1520| 3.34k| case 2:
------------------
| Branch (1520:3): [True: 3.34k, False: 5.60M]
------------------
1521| 3.34k|#line 122 "/src/igraph/src/io/gml-parser.y"
1522| 3.34k| { context->tree=(yyvsp[0].tree); }
1523| 3.34k|#line 1524 "/src/igraph/build/src/io/parsers/gml-parser.c"
1524| 3.34k| break;
1525| |
1526| 0| case 3:
------------------
| Branch (1526:3): [True: 0, False: 5.60M]
------------------
1527| 0|#line 124 "/src/igraph/src/io/gml-parser.y"
1528| 0| { IGRAPH_YY_CHECK(igraph_i_gml_make_empty(&(yyval.tree))); }
------------------
| | 10| 0| do { \
| | 11| 0| igraph_error_t igraph_i_ret = (expr); \
| | 12| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_gml_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 704| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 0| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 0]
| | ------------------
------------------
1529| 0|#line 1530 "/src/igraph/build/src/io/parsers/gml-parser.c"
1530| 0| break;
1531| |
1532| 385k| case 4:
------------------
| Branch (1532:3): [True: 385k, False: 5.22M]
------------------
1533| 385k|#line 125 "/src/igraph/src/io/gml-parser.y"
1534| 385k| { (yyval.tree)=(yyvsp[0].tree); }
1535| 385k|#line 1536 "/src/igraph/build/src/io/parsers/gml-parser.c"
1536| 385k| break;
1537| |
1538| 1.11M| case 5:
------------------
| Branch (1538:3): [True: 1.11M, False: 4.49M]
------------------
1539| 1.11M|#line 126 "/src/igraph/src/io/gml-parser.y"
1540| 1.11M| { IGRAPH_YY_CHECK(igraph_i_gml_merge((yyvsp[-1].tree), (yyvsp[0].tree))); (yyval.tree) = (yyvsp[-1].tree); }
------------------
| | 10| 1.11M| do { \
| | 11| 1.11M| igraph_error_t igraph_i_ret = (expr); \
| | 12| 1.11M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 1.11M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.11M]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_gml_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 704| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 1.11M| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 1.11M]
| | ------------------
------------------
1541| 0|#line 1542 "/src/igraph/build/src/io/parsers/gml-parser.c"
1542| 0| break;
1543| |
1544| 744k| case 6:
------------------
| Branch (1544:3): [True: 744k, False: 4.86M]
------------------
1545| 744k|#line 129 "/src/igraph/src/io/gml-parser.y"
1546| 744k| { IGRAPH_YY_CHECK(igraph_i_gml_make_numeric((yyvsp[-1].str), (yylsp[-1]).first_line, (yyvsp[0].real), &(yyval.tree))); }
------------------
| | 10| 744k| do { \
| | 11| 744k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 744k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 744k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 744k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_gml_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 704| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 744k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 744k]
| | ------------------
------------------
1547| 744k|#line 1548 "/src/igraph/build/src/io/parsers/gml-parser.c"
1548| 744k| break;
1549| |
1550| 744k| case 7:
------------------
| Branch (1550:3): [True: 370k, False: 5.23M]
------------------
1551| 370k|#line 131 "/src/igraph/src/io/gml-parser.y"
1552| 370k| { IGRAPH_YY_CHECK(igraph_i_gml_make_string((yyvsp[-1].str), (yylsp[-1]).first_line, (yyvsp[0].str), &(yyval.tree))); }
------------------
| | 10| 370k| do { \
| | 11| 370k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 370k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_gml_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 704| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 370k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 370k]
| | ------------------
------------------
1553| 370k|#line 1554 "/src/igraph/build/src/io/parsers/gml-parser.c"
1554| 370k| break;
1555| |
1556| 381k| case 8:
------------------
| Branch (1556:3): [True: 381k, False: 5.22M]
------------------
1557| 381k|#line 133 "/src/igraph/src/io/gml-parser.y"
1558| 381k| { IGRAPH_YY_CHECK(igraph_i_gml_make_list((yyvsp[-3].str), (yylsp[-3]).first_line, (yyvsp[-1].tree), &(yyval.tree))); }
------------------
| | 10| 381k| do { \
| | 11| 381k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 381k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 381k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 381k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_gml_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 704| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 381k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 381k]
| | ------------------
------------------
1559| 381k|#line 1560 "/src/igraph/build/src/io/parsers/gml-parser.c"
1560| 381k| break;
1561| |
1562| 1.49M| case 9:
------------------
| Branch (1562:3): [True: 1.49M, False: 4.11M]
------------------
1563| 1.49M|#line 136 "/src/igraph/src/io/gml-parser.y"
1564| 1.49M| { IGRAPH_YY_CHECK(igraph_i_gml_get_keyword(igraph_gml_yyget_text(scanner),
------------------
| | 10| 1.49M| do { \
| | 11| 1.49M| igraph_error_t igraph_i_ret = (expr); \
| | 12| 1.49M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 1.49M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.49M]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_gml_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 704| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 1.49M| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 1.49M]
| | ------------------
------------------
1565| 1.49M| igraph_gml_yyget_leng(scanner),
1566| 1.49M| &(yyval.str))); }
1567| 1.49M|#line 1568 "/src/igraph/build/src/io/parsers/gml-parser.c"
1568| 1.49M| break;
1569| |
1570| 1.49M| case 10:
------------------
| Branch (1570:3): [True: 744k, False: 4.86M]
------------------
1571| 744k|#line 139 "/src/igraph/src/io/gml-parser.y"
1572| 744k| {
1573| 744k| igraph_real_t val;
1574| 744k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_gml_yyget_text(scanner),
------------------
| | 10| 744k| do { \
| | 11| 744k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 744k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 744k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 744k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_gml_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 704| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 744k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 744k]
| | ------------------
------------------
1575| 744k| igraph_gml_yyget_leng(scanner),
1576| 744k| &val));
1577| 744k| (yyval.real)=val;
1578| 744k|}
1579| 0|#line 1580 "/src/igraph/build/src/io/parsers/gml-parser.c"
1580| 0| break;
1581| |
1582| 370k| case 11:
------------------
| Branch (1582:3): [True: 370k, False: 5.23M]
------------------
1583| 370k|#line 147 "/src/igraph/src/io/gml-parser.y"
1584| 370k| { IGRAPH_YY_CHECK(igraph_i_gml_get_string(igraph_gml_yyget_text(scanner),
------------------
| | 10| 370k| do { \
| | 11| 370k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 370k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_gml_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 704| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 370k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 370k]
| | ------------------
------------------
1585| 370k| igraph_gml_yyget_leng(scanner),
1586| 370k| &(yyval.str))); }
1587| 370k|#line 1588 "/src/igraph/build/src/io/parsers/gml-parser.c"
1588| 370k| break;
1589| |
1590| |
1591| 370k|#line 1592 "/src/igraph/build/src/io/parsers/gml-parser.c"
1592| |
1593| 370k| default: break;
------------------
| Branch (1593:7): [True: 0, False: 5.60M]
------------------
1594| 5.60M| }
1595| | /* User semantic actions sometimes alter yychar, and that requires
1596| | that yytoken be updated with the new translation. We take the
1597| | approach of translating immediately before every use of yytoken.
1598| | One alternative is translating here after every semantic action,
1599| | but that translation would be missed if the semantic action invokes
1600| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1601| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1602| | incorrect destructor might then be invoked immediately. In the
1603| | case of YYERROR or YYBACKUP, subsequent parser actions might lead
1604| | to an incorrect destructor call or verbose syntax error message
1605| | before the lookahead is translated. */
1606| 5.60M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1607| |
1608| 5.60M| YYPOPSTACK (yylen);
------------------
| | 1309| 5.60M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1609| 5.60M| yylen = 0;
1610| 5.60M| YY_STACK_PRINT (yyss, yyssp);
1611| |
1612| 5.60M| *++yyvsp = yyval;
1613| 5.60M| *++yylsp = yyloc;
1614| |
1615| | /* Now 'shift' the result of the reduction. Determine what state
1616| | that goes to, based on the state we popped back to and the rule
1617| | number reduced by. */
1618| 5.60M| {
1619| 5.60M| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 542| 5.60M|#define YYNTOKENS 9
------------------
1620| 5.60M| const int yyi = yypgoto[yylhs] + *yyssp;
1621| 5.60M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 539| 11.1M|#define YYLAST 10
------------------
| Branch (1621:16): [True: 5.58M, False: 26.7k]
| Branch (1621:28): [True: 5.58M, False: 0]
| Branch (1621:45): [True: 2.59M, False: 2.98M]
------------------
1622| 5.60M| ? yytable[yyi]
1623| 5.60M| : yydefgoto[yylhs]);
1624| 5.60M| }
1625| |
1626| 5.60M| goto yynewstate;
1627| |
1628| |
1629| |/*--------------------------------------.
1630| || yyerrlab -- here on detecting error. |
1631| |`--------------------------------------*/
1632| 0|yyerrlab:
1633| | /* Make sure we have latest lookahead translation. See comments at
1634| | user semantic actions for why this is necessary. */
1635| 0| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 700| 0|#define YYEMPTY (-2)
------------------
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 700| 0|#define YYEMPTY (-2)
------------------
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 557| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 551| 0|#define YYMAXUTOK 263
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 550| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (557:4): [True: 0, False: 0]
| | | Branch (557:18): [True: 0, False: 0]
| | ------------------
------------------
| Branch (1635:13): [True: 0, False: 0]
------------------
1636| |
1637| | /* If not already recovering from an error, report this error. */
1638| 0| if (!yyerrstatus)
------------------
| Branch (1638:7): [True: 0, False: 0]
------------------
1639| 0| {
1640| 0| ++yynerrs;
------------------
| | 71| 0|#define yynerrs igraph_gml_yynerrs
------------------
1641| |#if ! YYERROR_VERBOSE
1642| | yyerror (&yylloc, context, YY_("syntax error"));
1643| |#else
1644| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1645| 0| yyssp, yytoken)
1646| 0| {
1647| 0| char const *yymsgp = YY_("syntax error");
------------------
| | 344| 0|# define YY_(Msgid) Msgid
------------------
1648| 0| int yysyntax_error_status;
1649| 0| yysyntax_error_status = YYSYNTAX_ERROR;
------------------
| | 1644| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
| | 1645| 0| yyssp, yytoken)
------------------
1650| 0| if (yysyntax_error_status == 0)
------------------
| Branch (1650:13): [True: 0, False: 0]
------------------
1651| 0| yymsgp = yymsg;
1652| 0| else if (yysyntax_error_status == 1)
------------------
| Branch (1652:18): [True: 0, False: 0]
------------------
1653| 0| {
1654| 0| if (yymsg != yymsgbuf)
------------------
| Branch (1654:17): [True: 0, False: 0]
------------------
1655| 0| YYSTACK_FREE (yymsg);
------------------
| | 445| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 464| 0|# define YYFREE free
| | ------------------
------------------
1656| 0| yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
------------------
| | 143| 0|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1657| 0| if (!yymsg)
------------------
| Branch (1657:17): [True: 0, False: 0]
------------------
1658| 0| {
1659| 0| yymsg = yymsgbuf;
1660| 0| yymsg_alloc = sizeof yymsgbuf;
1661| 0| yysyntax_error_status = 2;
1662| 0| }
1663| 0| else
1664| 0| {
1665| 0| yysyntax_error_status = YYSYNTAX_ERROR;
------------------
| | 1644| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
| | 1645| 0| yyssp, yytoken)
------------------
1666| 0| yymsgp = yymsg;
1667| 0| }
1668| 0| }
1669| 0| yyerror (&yylloc, context, yymsgp);
------------------
| | 69| 0|#define yyerror igraph_gml_yyerror
------------------
1670| 0| if (yysyntax_error_status == 2)
------------------
| Branch (1670:13): [True: 0, False: 0]
------------------
1671| 0| goto yyexhaustedlab;
1672| 0| }
1673| 0|# undef YYSYNTAX_ERROR
1674| 0|#endif
1675| 0| }
1676| |
1677| 0| yyerror_range[1] = yylloc;
1678| |
1679| 0| if (yyerrstatus == 3)
------------------
| Branch (1679:7): [True: 0, False: 0]
------------------
1680| 0| {
1681| | /* If just tried and failed to reuse lookahead token after an
1682| | error, discard it. */
1683| |
1684| 0| if (yychar <= YYEOF)
------------------
| | 701| 0|#define YYEOF 0
------------------
| Branch (1684:11): [True: 0, False: 0]
------------------
1685| 0| {
1686| | /* Return failure if at end of input. */
1687| 0| if (yychar == YYEOF)
------------------
| | 701| 0|#define YYEOF 0
------------------
| Branch (1687:15): [True: 0, False: 0]
------------------
1688| 0| YYABORT;
------------------
| | 704| 0|#define YYABORT goto yyabortlab
------------------
1689| 0| }
1690| 0| else
1691| 0| {
1692| 0| yydestruct ("Error: discarding",
1693| 0| yytoken, &yylval, &yylloc, context);
1694| 0| yychar = YYEMPTY;
------------------
| | 700| 0|#define YYEMPTY (-2)
------------------
1695| 0| }
1696| 0| }
1697| |
1698| | /* Else will try to reuse lookahead token after shifting the error
1699| | token. */
1700| 0| goto yyerrlab1;
1701| |
1702| |
1703| |/*---------------------------------------------------.
1704| || yyerrorlab -- error raised explicitly by YYERROR. |
1705| |`---------------------------------------------------*/
1706| 0|yyerrorlab:
1707| | /* Pacify compilers when the user code never invokes YYERROR and the
1708| | label yyerrorlab therefore never appears in user code. */
1709| 0| if (0)
------------------
| Branch (1709:7): [Folded, False: 0]
------------------
1710| 0| YYERROR;
------------------
| | 705| 0|#define YYERROR goto yyerrorlab
------------------
1711| |
1712| | /* Do not reclaim the symbols of the rule whose action triggered
1713| | this YYERROR. */
1714| 0| YYPOPSTACK (yylen);
------------------
| | 1309| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1715| 0| yylen = 0;
1716| 0| YY_STACK_PRINT (yyss, yyssp);
1717| 0| yystate = *yyssp;
1718| 0| goto yyerrlab1;
1719| |
1720| |
1721| |/*-------------------------------------------------------------.
1722| || yyerrlab1 -- common code for both syntax error and YYERROR. |
1723| |`-------------------------------------------------------------*/
1724| 0|yyerrlab1:
1725| 0| yyerrstatus = 3; /* Each real token shifted decrements this. */
1726| |
1727| 0| for (;;)
1728| 0| {
1729| 0| yyn = yypact[yystate];
1730| 0| if (!yypact_value_is_default (yyn))
------------------
| | 624| 0| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 621| 0|#define YYPACT_NINF (-4)
| | ------------------
------------------
| Branch (1730:11): [True: 0, False: 0]
------------------
1731| 0| {
1732| 0| yyn += YYTERROR;
------------------
| | 728| 0|#define YYTERROR 1
------------------
1733| 0| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
------------------
| | 539| 0|#define YYLAST 10
------------------
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
------------------
| | 728| 0|#define YYTERROR 1
------------------
| Branch (1733:15): [True: 0, False: 0]
| Branch (1733:27): [True: 0, False: 0]
| Branch (1733:44): [True: 0, False: 0]
------------------
1734| 0| {
1735| 0| yyn = yytable[yyn];
1736| 0| if (0 < yyn)
------------------
| Branch (1736:19): [True: 0, False: 0]
------------------
1737| 0| break;
1738| 0| }
1739| 0| }
1740| |
1741| | /* Pop the current state because it cannot handle the error token. */
1742| 0| if (yyssp == yyss)
------------------
| Branch (1742:11): [True: 0, False: 0]
------------------
1743| 0| YYABORT;
------------------
| | 704| 0|#define YYABORT goto yyabortlab
------------------
1744| |
1745| 0| yyerror_range[1] = *yylsp;
1746| 0| yydestruct ("Error: popping",
1747| 0| yystos[yystate], yyvsp, yylsp, context);
1748| 0| YYPOPSTACK (1);
------------------
| | 1309| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1749| 0| yystate = *yyssp;
1750| 0| YY_STACK_PRINT (yyss, yyssp);
1751| 0| }
1752| |
1753| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1754| 0| *++yyvsp = yylval;
1755| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END
1756| |
1757| 0| yyerror_range[2] = yylloc;
1758| | /* Using YYLLOC is tempting, but would change the location of
1759| | the lookahead. YYLOC is available though. */
1760| 0| YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
------------------
| | 738| 0| do \
| | 739| 0| if (N) \
| | ------------------
| | | Branch (739:11): [True: 0, Folded]
| | ------------------
| | 740| 0| { \
| | 741| 0| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 756| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 742| 0| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 756| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 743| 0| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 756| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 744| 0| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 756| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 745| 0| } \
| | 746| 0| else \
| | 747| 0| { \
| | 748| 0| (Current).first_line = (Current).last_line = \
| | 749| 0| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 756| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 750| 0| (Current).first_column = (Current).last_column = \
| | 751| 0| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 756| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 752| 0| } \
| | 753| 0| while (0)
| | ------------------
| | | Branch (753:12): [Folded, False: 0]
| | ------------------
------------------
1761| 0| *++yylsp = yyloc;
1762| |
1763| | /* Shift the error token. */
1764| 0| YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1765| |
1766| 0| yystate = yyn;
1767| 0| goto yynewstate;
1768| |
1769| |
1770| |/*-------------------------------------.
1771| || yyacceptlab -- YYACCEPT comes here. |
1772| |`-------------------------------------*/
1773| 3.34k|yyacceptlab:
1774| 3.34k| yyresult = 0;
1775| 3.34k| goto yyreturn;
1776| |
1777| |
1778| |/*-----------------------------------.
1779| || yyabortlab -- YYABORT comes here. |
1780| |`-----------------------------------*/
1781| 0|yyabortlab:
1782| 0| yyresult = 1;
1783| 0| goto yyreturn;
1784| |
1785| |
1786| 0|#if !defined yyoverflow || YYERROR_VERBOSE
1787| |/*-------------------------------------------------.
1788| || yyexhaustedlab -- memory exhaustion comes here. |
1789| |`-------------------------------------------------*/
1790| 0|yyexhaustedlab:
1791| 0| yyerror (&yylloc, context, YY_("memory exhausted"));
------------------
| | 69| 0|#define yyerror igraph_gml_yyerror
------------------
yyerror (&yylloc, context, YY_("memory exhausted"));
------------------
| | 344| 0|# define YY_(Msgid) Msgid
------------------
1792| 0| yyresult = 2;
1793| | /* Fall through. */
1794| 0|#endif
1795| |
1796| |
1797| |/*-----------------------------------------------------.
1798| || yyreturn -- parsing is finished, return the result. |
1799| |`-----------------------------------------------------*/
1800| 3.34k|yyreturn:
1801| 3.34k| if (yychar != YYEMPTY)
------------------
| | 700| 3.34k|#define YYEMPTY (-2)
------------------
| Branch (1801:7): [True: 0, False: 3.34k]
------------------
1802| 0| {
1803| | /* Make sure we have latest lookahead translation. See comments at
1804| | user semantic actions for why this is necessary. */
1805| 0| yytoken = YYTRANSLATE (yychar);
------------------
| | 557| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 551| 0|#define YYMAXUTOK 263
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 550| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (557:4): [True: 0, False: 0]
| | | Branch (557:18): [True: 0, False: 0]
| | ------------------
------------------
1806| 0| yydestruct ("Cleanup: discarding lookahead",
1807| 0| yytoken, &yylval, &yylloc, context);
1808| 0| }
1809| | /* Do not reclaim the symbols of the rule whose action triggered
1810| | this YYABORT or YYACCEPT. */
1811| 3.34k| YYPOPSTACK (yylen);
------------------
| | 1309| 3.34k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1812| 3.34k| YY_STACK_PRINT (yyss, yyssp);
1813| 10.0k| while (yyssp != yyss)
------------------
| Branch (1813:10): [True: 6.68k, False: 3.34k]
------------------
1814| 6.68k| {
1815| 6.68k| yydestruct ("Cleanup: popping",
1816| 6.68k| yystos[+*yyssp], yyvsp, yylsp, context);
1817| 6.68k| YYPOPSTACK (1);
------------------
| | 1309| 6.68k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1818| 6.68k| }
1819| 3.34k|#ifndef yyoverflow
1820| 3.34k| if (yyss != yyssa)
------------------
| Branch (1820:7): [True: 0, False: 3.34k]
------------------
1821| 0| YYSTACK_FREE (yyss);
------------------
| | 445| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 464| 0|# define YYFREE free
| | ------------------
------------------
1822| 3.34k|#endif
1823| 3.34k|#if YYERROR_VERBOSE
1824| 3.34k| if (yymsg != yymsgbuf)
------------------
| Branch (1824:7): [True: 0, False: 3.34k]
------------------
1825| 0| YYSTACK_FREE (yymsg);
------------------
| | 445| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 464| 0|# define YYFREE free
| | ------------------
------------------
1826| 3.34k|#endif
1827| 3.34k| return yyresult;
1828| 0|}
gml-parser.c:yydestruct:
1189| 6.68k|{
1190| 6.68k| YYUSE (yyvaluep);
------------------
| | 366| 6.68k|# define YYUSE(E) ((void) (E))
------------------
1191| 6.68k| YYUSE (yylocationp);
------------------
| | 366| 6.68k|# define YYUSE(E) ((void) (E))
------------------
1192| 6.68k| YYUSE (context);
------------------
| | 366| 6.68k|# define YYUSE(E) ((void) (E))
------------------
1193| 6.68k| if (!yymsg)
------------------
| Branch (1193:7): [True: 0, False: 6.68k]
------------------
1194| 0| yymsg = "Deleting";
1195| 6.68k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1196| |
1197| 6.68k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1198| 6.68k| switch (yytype)
1199| 6.68k| {
1200| 0| case 11: /* list */
------------------
| Branch (1200:5): [True: 0, False: 6.68k]
------------------
1201| 0|#line 118 "/src/igraph/src/io/gml-parser.y"
1202| 0| { igraph_gml_tree_destroy(((*yyvaluep).tree)); }
1203| 0|#line 1204 "/src/igraph/build/src/io/parsers/gml-parser.c"
1204| 0| break;
1205| |
1206| 0| case 12: /* keyvalue */
------------------
| Branch (1206:5): [True: 0, False: 6.68k]
------------------
1207| 0|#line 118 "/src/igraph/src/io/gml-parser.y"
1208| 0| { igraph_gml_tree_destroy(((*yyvaluep).tree)); }
1209| 0|#line 1210 "/src/igraph/build/src/io/parsers/gml-parser.c"
1210| 0| break;
1211| |
1212| 0| case 13: /* key */
------------------
| Branch (1212:5): [True: 0, False: 6.68k]
------------------
1213| 0|#line 117 "/src/igraph/src/io/gml-parser.y"
1214| 0| { free(((*yyvaluep).str)); }
1215| 0|#line 1216 "/src/igraph/build/src/io/parsers/gml-parser.c"
1216| 0| break;
1217| |
1218| 0| case 15: /* string */
------------------
| Branch (1218:5): [True: 0, False: 6.68k]
------------------
1219| 0|#line 117 "/src/igraph/src/io/gml-parser.y"
1220| 0| { free(((*yyvaluep).str)); }
1221| 0|#line 1222 "/src/igraph/build/src/io/parsers/gml-parser.c"
1222| 0| break;
1223| |
1224| 6.68k| default:
------------------
| Branch (1224:7): [True: 6.68k, False: 0]
------------------
1225| 6.68k| break;
1226| 6.68k| }
1227| 6.68k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1228| 6.68k|}
gml-parser.c:igraph_i_gml_get_keyword:
1840| 1.49M|static igraph_error_t igraph_i_gml_get_keyword(const char *s, size_t len, char **res) {
1841| 1.49M| *res = strndup(s, len);
1842| 1.49M| if (! *res) {
------------------
| Branch (1842:7): [True: 0, False: 1.49M]
------------------
1843| 0| IGRAPH_ERROR("Cannot read GML file.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1844| 0| }
1845| 1.49M| return IGRAPH_SUCCESS;
1846| 1.49M|}
gml-parser.c:igraph_i_gml_get_string:
1848| 370k|static igraph_error_t igraph_i_gml_get_string(const char *s, size_t len, char **res) {
1849| 370k| *res = strndup(s+1, len-2);
1850| 370k| if (! *res) {
------------------
| Branch (1850:7): [True: 0, False: 370k]
------------------
1851| 0| IGRAPH_ERROR("Cannot read GML file.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1852| 0| }
1853| 370k| return IGRAPH_SUCCESS;
1854| 370k|}
gml-parser.c:igraph_i_gml_make_numeric:
1859| 744k| igraph_gml_tree_t **tree) {
1860| |
1861| 744k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 744k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.48M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 744k, Folded]
| | | | ------------------
| | ------------------
------------------
1862| 744k| if (!t) {
------------------
| Branch (1862:7): [True: 0, False: 744k]
------------------
1863| 0| IGRAPH_ERROR("Cannot build GML tree.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1864| 0| }
1865| 744k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 744k| do { \
| | 604| 744k| /* the following branch makes the compiler check the compatibility of \
| | 605| 744k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 744k| * incorrect destructor function with the pointer */ \
| | 607| 744k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 744k]
| | ------------------
| | 608| 744k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 744k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 744k]
| | ------------------
------------------
1866| |
1867| | /* The GML spec only requires support for 32-bit signed integers,
1868| | * but igraph tries to support the same range as igraph_int_t,
1869| | * so that it can read/write all graphs it can represent.
1870| | * We treat anything out of that range as real. These values end
1871| | * up as igraph_real_t anyway, as igraph does not currently support
1872| | * integer-typed attributes. */
1873| 744k| igraph_real_t trunc_value = trunc(value);
1874| 744k| if (value == trunc_value && igraph_i_is_real_representable_as_integer(trunc_value)) {
------------------
| Branch (1874:7): [True: 743k, False: 680]
| Branch (1874:31): [True: 743k, False: 221]
------------------
1875| 743k| IGRAPH_CHECK(igraph_gml_tree_init_integer(t, name, line, value));
------------------
| | 656| 743k| do { \
| | 657| 743k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 743k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 743k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 743k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 743k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 743k]
| | ------------------
------------------
1876| 743k| } else {
1877| 901| IGRAPH_CHECK(igraph_gml_tree_init_real(t, name, line, value));
------------------
| | 656| 901| do { \
| | 657| 901| igraph_error_t igraph_i_ret = (expr); \
| | 658| 901| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 901| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 901]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 901| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 901]
| | ------------------
------------------
1878| 901| }
1879| |
1880| 744k| *tree = t;
1881| 744k| IGRAPH_FINALLY_CLEAN(1); /* t */
1882| |
1883| 744k| return IGRAPH_SUCCESS;
1884| 744k|}
gml-parser.c:igraph_i_gml_make_string:
1889| 370k| igraph_gml_tree_t **tree) {
1890| |
1891| 370k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 370k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 740k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 370k, Folded]
| | | | ------------------
| | ------------------
------------------
1892| 370k| if (!t) {
------------------
| Branch (1892:7): [True: 0, False: 370k]
------------------
1893| 0| IGRAPH_ERROR("Cannot build GML tree.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1894| 0| }
1895| 370k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 370k| do { \
| | 604| 370k| /* the following branch makes the compiler check the compatibility of \
| | 605| 370k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 370k| * incorrect destructor function with the pointer */ \
| | 607| 370k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 370k]
| | ------------------
| | 608| 370k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 370k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 370k]
| | ------------------
------------------
1896| |
1897| | /* if igraph_gml_tree_init_string succeeds, the newly created tree node takes
1898| | * ownership of 'value'. If it fails, we need to free 'value' ourselves in order
1899| | * not to leak memory */
1900| 370k| IGRAPH_FINALLY(igraph_free, value);
------------------
| | 603| 370k| do { \
| | 604| 370k| /* the following branch makes the compiler check the compatibility of \
| | 605| 370k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 370k| * incorrect destructor function with the pointer */ \
| | 607| 370k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 370k]
| | ------------------
| | 608| 370k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 370k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 370k]
| | ------------------
------------------
1901| 370k| IGRAPH_CHECK(igraph_gml_tree_init_string(t, name, line, value));
------------------
| | 656| 370k| do { \
| | 657| 370k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 370k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 370k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 370k]
| | ------------------
------------------
1902| |
1903| 370k| IGRAPH_FINALLY_CLEAN(1); /* value */
1904| |
1905| 370k| *tree = t;
1906| 370k| IGRAPH_FINALLY_CLEAN(1); /* t */
1907| |
1908| 370k| return IGRAPH_SUCCESS;
1909| 370k|}
gml-parser.c:igraph_i_gml_make_list:
1914| 381k| igraph_gml_tree_t **tree) {
1915| |
1916| 381k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 381k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 763k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 381k, Folded]
| | | | ------------------
| | ------------------
------------------
1917| 381k| if (!t) {
------------------
| Branch (1917:7): [True: 0, False: 381k]
------------------
1918| 0| IGRAPH_ERROR("Cannot build GML tree.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1919| 0| }
1920| 381k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 381k| do { \
| | 604| 381k| /* the following branch makes the compiler check the compatibility of \
| | 605| 381k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 381k| * incorrect destructor function with the pointer */ \
| | 607| 381k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 381k]
| | ------------------
| | 608| 381k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 381k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 381k]
| | ------------------
------------------
1921| |
1922| 381k| IGRAPH_CHECK(igraph_gml_tree_init_tree(t, name, line, list));
------------------
| | 656| 381k| do { \
| | 657| 381k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 381k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 381k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 381k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 381k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 381k]
| | ------------------
------------------
1923| |
1924| 381k| *tree = t;
1925| 381k| IGRAPH_FINALLY_CLEAN(1); /* t */
1926| |
1927| 381k| return IGRAPH_SUCCESS;
1928| 381k|}
gml-parser.c:igraph_i_gml_merge:
1945| 1.11M|static igraph_error_t igraph_i_gml_merge(igraph_gml_tree_t *t1, igraph_gml_tree_t* t2) {
1946| |
1947| 1.11M| IGRAPH_CHECK(igraph_gml_tree_mergedest(t1, t2));
------------------
| | 656| 1.11M| do { \
| | 657| 1.11M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.11M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.11M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.11M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.11M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.11M]
| | ------------------
------------------
1948| 1.11M| IGRAPH_FREE(t2);
------------------
| | 36| 1.11M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1949| |
1950| 1.11M| return IGRAPH_SUCCESS;
1951| 1.11M|}
igraph_lgl_yylex:
994| 820k|{
995| 820k| yy_state_type yy_current_state;
996| 820k| char *yy_cp, *yy_bp;
997| 820k| int yy_act;
998| 820k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
999| |
1000| 820k| yylval = yylval_param;
------------------
| | 807| 820k| # define yylval yyg->yylval_r
------------------
1001| |
1002| 820k| yylloc = yylloc_param;
------------------
| | 809| 820k| # define yylloc yyg->yylloc_r
------------------
1003| |
1004| 820k| if ( !yyg->yy_init )
------------------
| Branch (1004:7): [True: 3.19k, False: 817k]
------------------
1005| 3.19k| {
1006| 3.19k| yyg->yy_init = 1;
1007| |
1008| |#ifdef YY_USER_INIT
1009| | YY_USER_INIT;
1010| |#endif
1011| |
1012| 3.19k| if ( ! yyg->yy_start )
------------------
| Branch (1012:8): [True: 3.19k, False: 0]
------------------
1013| 3.19k| yyg->yy_start = 1; /* first start state */
1014| |
1015| 3.19k| if ( ! yyin )
------------------
| | 356| 3.19k|#define yyin yyg->yyin_r
------------------
| Branch (1015:8): [True: 0, False: 3.19k]
------------------
1016| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1017| |
1018| 3.19k| if ( ! yyout )
------------------
| | 357| 3.19k|#define yyout yyg->yyout_r
------------------
| Branch (1018:8): [True: 3.19k, False: 0]
------------------
1019| 3.19k| yyout = stdout;
------------------
| | 357| 3.19k|#define yyout yyg->yyout_r
------------------
1020| |
1021| 3.19k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.19k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.19k]
| | ------------------
| | 522| 3.19k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.19k| : NULL)
------------------
| Branch (1021:8): [True: 3.19k, False: 0]
------------------
1022| 3.19k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.19k|#define yyensure_buffer_stack igraph_lgl_yyensure_buffer_stack
------------------
1023| 3.19k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1024| 3.19k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.19k|#define yy_create_buffer igraph_lgl_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.19k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.19k|#define YY_BUF_SIZE 16384
------------------
1025| 3.19k| }
1026| |
1027| 3.19k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.19k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1028| 3.19k| }
1029| |
1030| 820k| {
1031| 820k|#line 79 "/src/igraph/src/io/lgl-lexer.l"
1032| |
1033| |
1034| 820k|#line 82 "/src/igraph/src/io/lgl-lexer.l"
1035| | /* ------------------------------------------------whitespace------*/
1036| 820k|#line 1037 "/src/igraph/build/src/io/parsers/lgl-lexer.c"
1037| |
1038| 928k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1038:23): [True: 928k, Folded]
------------------
1039| 928k| {
1040| 928k| yy_cp = yyg->yy_c_buf_p;
1041| |
1042| | /* Support of yytext. */
1043| 928k| *yy_cp = yyg->yy_hold_char;
1044| |
1045| | /* yy_bp points to the position in yy_ch_buf of the start of
1046| | * the current run.
1047| | */
1048| 928k| yy_bp = yy_cp;
1049| |
1050| 928k| yy_current_state = yyg->yy_start;
1051| 936k|yy_match:
1052| 936k| do
1053| 47.2M| {
1054| 47.2M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 47.2M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1055| 47.2M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1055:9): [True: 46.3M, False: 930k]
------------------
1056| 46.3M| {
1057| 46.3M| yyg->yy_last_accepting_state = yy_current_state;
1058| 46.3M| yyg->yy_last_accepting_cpos = yy_cp;
1059| 46.3M| }
1060| 95.0M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1060:12): [True: 47.8M, False: 47.2M]
------------------
1061| 47.8M| {
1062| 47.8M| yy_current_state = (int) yy_def[yy_current_state];
1063| 47.8M| if ( yy_current_state >= 16 )
------------------
| Branch (1063:10): [True: 46.3M, False: 1.49M]
------------------
1064| 46.3M| yy_c = yy_meta[yy_c];
1065| 47.8M| }
1066| 47.2M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1067| 47.2M| ++yy_cp;
1068| 47.2M| }
1069| 47.2M| while ( yy_base[yy_current_state] != 12 );
------------------
| Branch (1069:11): [True: 46.3M, False: 936k]
------------------
1070| |
1071| 938k|yy_find_action:
1072| 938k| yy_act = yy_accept[yy_current_state];
1073| 938k| if ( yy_act == 0 )
------------------
| Branch (1073:8): [True: 923k, False: 15.2k]
------------------
1074| 923k| { /* have to back up */
1075| 923k| yy_cp = yyg->yy_last_accepting_cpos;
1076| 923k| yy_current_state = yyg->yy_last_accepting_state;
1077| 923k| yy_act = yy_accept[yy_current_state];
1078| 923k| }
1079| |
1080| 938k| YY_DO_BEFORE_ACTION;
------------------
| | 590| 938k| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 938k|#define yytext_ptr yytext_r
| | ------------------
| | 591| 938k| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 938k|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 938k| yyg->yy_hold_char = *yy_cp; \
| | 593| 938k| *yy_cp = '\0'; \
| | 594| 938k| yyg->yy_c_buf_p = yy_cp;
------------------
1081| |
1082| 938k| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 1.87M|#define YY_END_OF_BUFFER 7
------------------
| Branch (1082:8): [True: 925k, False: 13.5k]
| Branch (1082:38): [True: 354k, False: 570k]
------------------
1083| 354k| {
1084| 354k| int yyl;
1085| 709k| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 709k|#define yyleng yyg->yyleng_r
------------------
| Branch (1085:19): [True: 354k, False: 354k]
------------------
1086| 354k| if ( yytext[yyl] == '\n' )
------------------
| | 360| 354k|#define yytext yyg->yytext_r
------------------
| Branch (1086:10): [True: 354k, False: 0]
------------------
1087| |
1088| 354k| do{ yylineno++;
------------------
| | 361| 354k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 354k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1089| 354k| yycolumn=0;
------------------
| | 362| 354k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 354k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1090| 354k| }while(0)
------------------
| Branch (1090:12): [Folded, False: 354k]
------------------
1091| 354k|;
1092| 354k| }
1093| |
1094| 941k|do_action: /* This label is used only to access EOF actions. */
1095| |
1096| 941k| switch ( yy_act )
1097| 941k| { /* beginning of action switch */
1098| 0| case 0: /* must back up */
------------------
| Branch (1098:4): [True: 0, False: 941k]
------------------
1099| | /* undo the effects of YY_DO_BEFORE_ACTION */
1100| 0| *yy_cp = yyg->yy_hold_char;
1101| 0| yy_cp = yyg->yy_last_accepting_cpos;
1102| 0| yy_current_state = yyg->yy_last_accepting_state;
1103| 0| goto yy_find_action;
1104| |
1105| 107k|case 1:
------------------
| Branch (1105:1): [True: 107k, False: 834k]
------------------
1106| 107k|YY_RULE_SETUP
------------------
| | 989| 107k| YY_USER_ACTION
| | ------------------
| | | | 735| 107k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1107| 107k|#line 83 "/src/igraph/src/io/lgl-lexer.l"
1108| 107k|{ /* skip space */ }
1109| 107k| YY_BREAK
------------------
| | 985| 107k|#define YY_BREAK /*LINTED*/break;
------------------
1110| |/* --------------------------------------------------hashmark------*/
1111| 12.9k|case 2:
------------------
| Branch (1111:1): [True: 12.9k, False: 929k]
------------------
1112| 12.9k|YY_RULE_SETUP
------------------
| | 989| 12.9k| YY_USER_ACTION
| | ------------------
| | | | 735| 12.9k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 12.9k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 12.9k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 12.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1113| 12.9k|#line 86 "/src/igraph/src/io/lgl-lexer.l"
1114| 12.9k|{ BEGIN(LINE); return HASH; }
------------------
| | 369| 12.9k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return HASH; }
------------------
| | 751| 12.9k|#define LINE 1
------------------
1115| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1116| |/* ----------------------------------------------alphanumeric------*/
1117| 449k|case 3:
------------------
| Branch (1117:1): [True: 449k, False: 492k]
------------------
1118| 449k|YY_RULE_SETUP
------------------
| | 989| 449k| YY_USER_ACTION
| | ------------------
| | | | 735| 449k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 449k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 449k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 449k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1119| 449k|#line 89 "/src/igraph/src/io/lgl-lexer.l"
1120| 449k|{ BEGIN(LINE); return ALNUM; }
------------------
| | 369| 449k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return ALNUM; }
------------------
| | 751| 449k|#define LINE 1
------------------
1121| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1122| |/* ---------------------------------------------------newline------*/
1123| 354k|case 4:
------------------
| Branch (1123:1): [True: 354k, False: 587k]
------------------
1124| |/* rule 4 can match eol */
1125| 354k|#line 93 "/src/igraph/src/io/lgl-lexer.l"
1126| 354k|YY_RULE_SETUP
------------------
| | 989| 354k| YY_USER_ACTION
| | ------------------
| | | | 735| 354k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 354k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 354k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 354k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1127| 354k|case YY_STATE_EOF(LINE):
------------------
| | 377| 354k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 354k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
| Branch (1127:1): [True: 0, False: 941k]
------------------
1128| 354k|#line 93 "/src/igraph/src/io/lgl-lexer.l"
1129| 354k|{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 369| 354k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 750| 354k|#define INITIAL 0
------------------
1130| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1131| |/* ---------------------------------------------anything else------*/
1132| 0|case 5:
------------------
| Branch (1132:1): [True: 0, False: 941k]
------------------
1133| 0|YY_RULE_SETUP
------------------
| | 989| 0| YY_USER_ACTION
| | ------------------
| | | | 735| 0|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1134| 0|#line 96 "/src/igraph/src/io/lgl-lexer.l"
1135| 0|{ return ERROR; }
1136| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1137| 0|case 6:
------------------
| Branch (1137:1): [True: 0, False: 941k]
------------------
1138| 0|YY_RULE_SETUP
------------------
| | 989| 0| YY_USER_ACTION
| | ------------------
| | | | 735| 0|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1139| 0|#line 98 "/src/igraph/src/io/lgl-lexer.l"
1140| 0|YY_FATAL_ERROR( "flex scanner jammed" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1141| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1142| 0|#line 1143 "/src/igraph/build/src/io/parsers/lgl-lexer.c"
1143| 3.19k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.19k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.19k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
| Branch (1143:1): [True: 3.19k, False: 938k]
------------------
1144| 3.19k| yyterminate();
------------------
| | 948| 3.19k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.19k|#define YY_NULL 0
| | ------------------
------------------
1145| |
1146| 13.5k| case YY_END_OF_BUFFER:
------------------
| | 596| 13.5k|#define YY_END_OF_BUFFER 7
------------------
| Branch (1146:2): [True: 13.5k, False: 928k]
------------------
1147| 13.5k| {
1148| | /* Amount of text matched not including the EOB char. */
1149| 13.5k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 13.5k|#define yytext_ptr yytext_r
------------------
1150| |
1151| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1152| 13.5k| *yy_cp = yyg->yy_hold_char;
1153| 13.5k| YY_RESTORE_YY_MORE_OFFSET
1154| |
1155| 13.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 498| 13.5k|#define YY_BUFFER_NEW 0
------------------
| Branch (1155:8): [True: 3.19k, False: 10.3k]
------------------
1156| 3.19k| {
1157| | /* We're scanning a new file or input source. It's
1158| | * possible that this happened because the user
1159| | * just pointed yyin at a new source and called
1160| | * yylex(). If so, then we have to assure
1161| | * consistency between YY_CURRENT_BUFFER and our
1162| | * globals. Here is the right place to do so, because
1163| | * this is the first action (other than possibly a
1164| | * back-up) that will match for the new input source.
1165| | */
1166| 3.19k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1167| 3.19k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.19k|#define yyin yyg->yyin_r
------------------
1168| 3.19k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.19k|#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.19k|#define YY_BUFFER_NORMAL 1
------------------
1169| 3.19k| }
1170| |
1171| | /* Note that here we test for yy_c_buf_p "<=" to the position
1172| | * of the first EOB in the buffer, since yy_c_buf_p will
1173| | * already have been incremented past the NUL character
1174| | * (since all states make transitions on EOB to the
1175| | * end-of-buffer state). Contrast this with the test
1176| | * in input().
1177| | */
1178| 13.5k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1178:8): [True: 0, False: 13.5k]
------------------
1179| 0| { /* This was really a NUL. */
1180| 0| yy_state_type yy_next_state;
1181| |
1182| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
1183| |
1184| 0| yy_current_state = yy_get_previous_state( yyscanner );
1185| |
1186| | /* Okay, we're now positioned to make the NUL
1187| | * transition. We couldn't have
1188| | * yy_get_previous_state() go ahead and do it
1189| | * for us because it doesn't know how to deal
1190| | * with the possibility of jamming (and we don't
1191| | * want to build jamming into it because then it
1192| | * will run more slowly).
1193| | */
1194| |
1195| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1196| |
1197| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 0|#define YY_MORE_ADJ 0
------------------
1198| |
1199| 0| if ( yy_next_state )
------------------
| Branch (1199:9): [True: 0, False: 0]
------------------
1200| 0| {
1201| | /* Consume the NUL. */
1202| 0| yy_cp = ++yyg->yy_c_buf_p;
1203| 0| yy_current_state = yy_next_state;
1204| 0| goto yy_match;
1205| 0| }
1206| |
1207| 0| else
1208| 0| {
1209| 0| yy_cp = yyg->yy_c_buf_p;
1210| 0| goto yy_find_action;
1211| 0| }
1212| 0| }
1213| |
1214| 13.5k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1214:17): [True: 13.5k, False: 0]
------------------
1215| 13.5k| {
1216| 3.19k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.19k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1216:4): [True: 3.19k, False: 10.3k]
------------------
1217| 3.19k| {
1218| 3.19k| yyg->yy_did_buffer_switch_on_eof = 0;
1219| |
1220| 3.19k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.19k|#define yywrap igraph_lgl_yywrap
| | ------------------
| | | | 573| 3.19k|#define igraph_lgl_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:38): [True: 3.19k, Folded]
| | | | ------------------
| | ------------------
------------------
1221| 3.19k| {
1222| | /* Note: because we've taken care in
1223| | * yy_get_next_buffer() to have set up
1224| | * yytext, we can now set up
1225| | * yy_c_buf_p so that if some total
1226| | * hoser (like flex itself) wants to
1227| | * call the scanner after we return the
1228| | * YY_NULL, it'll still work - another
1229| | * YY_NULL will get returned.
1230| | */
1231| 3.19k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.19k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 3.19k|#define YY_MORE_ADJ 0
------------------
1232| |
1233| 3.19k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.19k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.19k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
1234| 3.19k| goto do_action;
1235| 3.19k| }
1236| |
1237| 0| else
1238| 0| {
1239| 0| if ( ! yyg->yy_did_buffer_switch_on_eof )
------------------
| Branch (1239:11): [True: 0, False: 0]
------------------
1240| 0| YY_NEW_FILE;
------------------
| | 379| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner )
| | ------------------
| | | | 98| 0|#define yyrestart igraph_lgl_yyrestart
| | ------------------
| | #define YY_NEW_FILE yyrestart( yyin , yyscanner )
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
------------------
1241| 0| }
1242| 0| break;
1243| 3.19k| }
1244| |
1245| 8.09k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 8.09k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1245:4): [True: 8.09k, False: 5.49k]
------------------
1246| 8.09k| yyg->yy_c_buf_p =
1247| 8.09k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 8.09k|#define yytext_ptr yytext_r
------------------
1248| |
1249| 8.09k| yy_current_state = yy_get_previous_state( yyscanner );
1250| |
1251| 8.09k| yy_cp = yyg->yy_c_buf_p;
1252| 8.09k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 8.09k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 8.09k|#define YY_MORE_ADJ 0
------------------
1253| 8.09k| goto yy_match;
1254| |
1255| 2.30k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 2.30k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1255:4): [True: 2.30k, False: 11.2k]
------------------
1256| 2.30k| yyg->yy_c_buf_p =
1257| 2.30k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 2.30k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1258| |
1259| 2.30k| yy_current_state = yy_get_previous_state( yyscanner );
1260| |
1261| 2.30k| yy_cp = yyg->yy_c_buf_p;
1262| 2.30k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 2.30k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 2.30k|#define YY_MORE_ADJ 0
------------------
1263| 2.30k| goto yy_find_action;
1264| 13.5k| }
1265| 0| break;
1266| 13.5k| }
1267| |
1268| 0| default:
------------------
| Branch (1268:2): [True: 0, False: 941k]
------------------
1269| 0| YY_FATAL_ERROR(
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1270| 941k| "fatal flex scanner internal error--no action found" );
1271| 941k| } /* end of action switch */
1272| 941k| } /* end of scanning one token */
1273| 820k| } /* end of user's declarations */
1274| 820k|} /* end of yylex */
igraph_lgl_yyrestart:
1572| 3.19k|{
1573| 3.19k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1574| |
1575| 3.19k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.19k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.19k, False: 0]
| | ------------------
| | 522| 3.19k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.19k| : NULL)
------------------
| Branch (1575:7): [True: 0, False: 3.19k]
------------------
1576| 0| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 0|#define yyensure_buffer_stack igraph_lgl_yyensure_buffer_stack
------------------
1577| 0| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1578| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 0|#define yy_create_buffer igraph_lgl_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
------------------
1579| 0| }
1580| |
1581| 3.19k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.19k|#define yy_init_buffer igraph_lgl_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.19k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.19k, False: 0]
| | ------------------
| | 522| 3.19k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.19k| : NULL)
------------------
1582| 3.19k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.19k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1583| 3.19k|}
igraph_lgl_yy_create_buffer:
1637| 3.19k|{
1638| 3.19k| YY_BUFFER_STATE b;
1639| |
1640| 3.19k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.19k|#define yyalloc igraph_lgl_yyalloc
------------------
1641| 3.19k| if ( ! b )
------------------
| Branch (1641:7): [True: 0, False: 3.19k]
------------------
1642| 3.19k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1643| |
1644| 3.19k| b->yy_buf_size = size;
1645| |
1646| | /* yy_ch_buf has to be 2 characters longer than the size given because
1647| | * we need to put in 2 end-of-buffer characters.
1648| | */
1649| 3.19k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.19k|#define yyalloc igraph_lgl_yyalloc
------------------
1650| 3.19k| if ( ! b->yy_ch_buf )
------------------
| Branch (1650:7): [True: 0, False: 3.19k]
------------------
1651| 3.19k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1652| |
1653| 3.19k| b->yy_is_our_buffer = 1;
1654| |
1655| 3.19k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.19k|#define yy_init_buffer igraph_lgl_yy_init_buffer
------------------
1656| |
1657| 3.19k| return b;
1658| 3.19k|}
igraph_lgl_yy_delete_buffer:
1665| 3.19k|{
1666| 3.19k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1667| |
1668| 3.19k| if ( ! b )
------------------
| Branch (1668:7): [True: 0, False: 3.19k]
------------------
1669| 0| return;
1670| |
1671| 3.19k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.19k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.19k, False: 0]
| | ------------------
| | 522| 3.19k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.19k| : NULL)
------------------
| Branch (1671:7): [True: 3.19k, False: 0]
------------------
1672| 3.19k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1673| |
1674| 3.19k| if ( b->yy_is_our_buffer )
------------------
| Branch (1674:7): [True: 3.19k, False: 0]
------------------
1675| 3.19k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.19k|#define yyfree igraph_lgl_yyfree
------------------
1676| |
1677| 3.19k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.19k|#define yyfree igraph_lgl_yyfree
------------------
1678| 3.19k|}
igraph_lgl_yy_flush_buffer:
1714| 6.38k|{
1715| 6.38k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1716| 6.38k| if ( ! b )
------------------
| Branch (1716:7): [True: 0, False: 6.38k]
------------------
1717| 0| return;
1718| |
1719| 6.38k| b->yy_n_chars = 0;
1720| |
1721| | /* We always need two end-of-buffer characters. The first causes
1722| | * a transition to the end-of-buffer state. The second causes
1723| | * a jam in that state.
1724| | */
1725| 6.38k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.38k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1726| 6.38k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.38k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1727| |
1728| 6.38k| b->yy_buf_pos = &b->yy_ch_buf[0];
1729| |
1730| 6.38k| b->yy_at_bol = 1;
1731| 6.38k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 6.38k|#define YY_BUFFER_NEW 0
------------------
1732| |
1733| 6.38k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 6.38k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.38k, False: 0]
| | ------------------
| | 522| 6.38k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.38k| : NULL)
------------------
| Branch (1733:7): [True: 3.19k, False: 3.19k]
------------------
1734| 3.19k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.19k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1735| 6.38k|}
igraph_lgl_yypop_buffer_state:
1775| 3.19k|{
1776| 3.19k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1777| 3.19k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.19k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.19k, False: 0]
| | ------------------
| | 522| 3.19k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.19k| : NULL)
------------------
| Branch (1777:6): [True: 3.19k, False: 0]
------------------
1778| 3.19k| return;
1779| |
1780| 0| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
------------------
| | 26| 0|#define yy_delete_buffer igraph_lgl_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)
------------------
1781| 0| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1782| 0| if (yyg->yy_buffer_stack_top > 0)
------------------
| Branch (1782:6): [True: 0, False: 0]
------------------
1783| 0| --yyg->yy_buffer_stack_top;
1784| |
1785| 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)
------------------
1786| 0| yy_load_buffer_state( yyscanner );
------------------
| | 62| 0|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1787| 0| yyg->yy_did_buffer_switch_on_eof = 1;
1788| 0| }
1789| 0|}
igraph_lgl_yyget_leng:
2012| 449k|{
2013| 449k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2014| 449k| return yyleng;
------------------
| | 359| 449k|#define yyleng yyg->yyleng_r
------------------
2015| 449k|}
igraph_lgl_yyget_text:
2022| 449k|{
2023| 449k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2024| 449k| return yytext;
------------------
| | 360| 449k|#define yytext yyg->yytext_r
------------------
2025| 449k|}
igraph_lgl_yyset_extra:
2032| 6.38k|{
2033| 6.38k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2034| 6.38k| yyextra = user_defined ;
------------------
| | 358| 6.38k|#define yyextra yyg->yyextra_r
------------------
2035| 6.38k|}
igraph_lgl_yyset_in:
2074| 3.19k|{
2075| 3.19k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2076| 3.19k| yyin = _in_str ;
------------------
| | 356| 3.19k|#define yyin yyg->yyin_r
------------------
2077| 3.19k|}
igraph_lgl_yylex_init_extra:
2157| 3.19k|{
2158| 3.19k| struct yyguts_t dummy_yyguts;
2159| |
2160| 3.19k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.19k|#define yyset_extra igraph_lgl_yyset_extra
------------------
2161| |
2162| 3.19k| if (ptr_yy_globals == NULL){
------------------
| Branch (2162:9): [True: 0, False: 3.19k]
------------------
2163| 0| errno = EINVAL;
2164| 0| return 1;
2165| 0| }
2166| |
2167| 3.19k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.19k|#define yyalloc igraph_lgl_yyalloc
------------------
2168| |
2169| 3.19k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2169:9): [True: 0, False: 3.19k]
------------------
2170| 0| errno = ENOMEM;
2171| 0| return 1;
2172| 0| }
2173| |
2174| | /* By setting to 0xAA, we expose bugs in
2175| | yy_init_globals. Leave at 0x00 for releases. */
2176| 3.19k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2177| |
2178| 3.19k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.19k|#define yyset_extra igraph_lgl_yyset_extra
------------------
2179| |
2180| 3.19k| return yy_init_globals ( *ptr_yy_globals );
2181| 3.19k|}
igraph_lgl_yylex_destroy:
2218| 3.19k|{
2219| 3.19k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2220| |
2221| | /* Pop the buffer stack, destroying each element. */
2222| 6.38k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 6.38k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.19k, False: 3.19k]
| | | Branch (521:29): [True: 6.38k, False: 0]
| | ------------------
| | 522| 6.38k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.38k| : NULL)
------------------
2223| 3.19k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.19k|#define yy_delete_buffer igraph_lgl_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.19k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.19k, False: 0]
| | ------------------
| | 522| 3.19k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.19k| : NULL)
------------------
2224| 3.19k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2225| 3.19k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.19k|#define yypop_buffer_state igraph_lgl_yypop_buffer_state
------------------
2226| 3.19k| }
2227| |
2228| | /* Destroy the stack itself. */
2229| 3.19k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.19k|#define yyfree igraph_lgl_yyfree
------------------
2230| 3.19k| yyg->yy_buffer_stack = NULL;
2231| |
2232| | /* Destroy the start condition stack. */
2233| 3.19k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.19k|#define yyfree igraph_lgl_yyfree
------------------
2234| 3.19k| yyg->yy_start_stack = NULL;
2235| |
2236| | /* Reset the globals. This is important in a non-reentrant scanner so the next time
2237| | * yylex() is called, initialization will occur. */
2238| 3.19k| yy_init_globals( yyscanner);
2239| |
2240| | /* Destroy the main struct (reentrant only). */
2241| 3.19k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.19k|#define yyfree igraph_lgl_yyfree
------------------
2242| | yyscanner = NULL;
2243| 3.19k| return 0;
2244| 3.19k|}
igraph_lgl_yyalloc:
2274| 12.7k|{
2275| 12.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2276| 12.7k| (void)yyg;
2277| 12.7k| return malloc(size);
2278| 12.7k|}
igraph_lgl_yyrealloc:
2281| 84|{
2282| 84| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2283| 84| (void)yyg;
2284| |
2285| | /* The cast to (char *) in the following accommodates both
2286| | * implementations that use char* generic pointers, and those
2287| | * that use void* generic pointers. It works with the latter
2288| | * because both ANSI C and C++ allow castless assignment from
2289| | * any pointer type to void*, and deal with argument conversions
2290| | * as though doing an assignment.
2291| | */
2292| 84| return realloc(ptr, size);
2293| 84|}
igraph_lgl_yyfree:
2296| 15.9k|{
2297| 15.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2298| 15.9k| (void)yyg;
2299| 15.9k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2300| 15.9k|}
lgl-lexer.c:yy_get_next_buffer:
1284| 13.5k|{
1285| 13.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1286| 13.5k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1287| 13.5k| char *source = yyg->yytext_ptr;
------------------
| | 579| 13.5k|#define yytext_ptr yytext_r
------------------
1288| 13.5k| int number_to_move, i;
1289| 13.5k| int ret_val;
1290| |
1291| 13.5k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1291:7): [True: 0, False: 13.5k]
------------------
1292| 13.5k| YY_FATAL_ERROR(
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1293| 13.5k| "fatal flex scanner internal error--end of buffer missed" );
1294| |
1295| 13.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1295:7): [True: 0, False: 13.5k]
------------------
1296| 0| { /* Don't try to fill the buffer, so this is an EOF. */
1297| 0| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
------------------
| | 681| 0|#define YY_MORE_ADJ 0
------------------
| Branch (1297:8): [True: 0, False: 0]
------------------
1298| 0| {
1299| | /* We matched a single character, the EOB, so
1300| | * treat this as a final EOF.
1301| | */
1302| 0| return EOB_ACT_END_OF_FILE;
------------------
| | 410| 0|#define EOB_ACT_END_OF_FILE 1
------------------
1303| 0| }
1304| |
1305| 0| else
1306| 0| {
1307| | /* We matched some text prior to the EOB, first
1308| | * process it.
1309| | */
1310| 0| return EOB_ACT_LAST_MATCH;
------------------
| | 411| 0|#define EOB_ACT_LAST_MATCH 2
------------------
1311| 0| }
1312| 0| }
1313| |
1314| | /* Try to read more data. */
1315| |
1316| | /* First move last chars to start of buffer. */
1317| 13.5k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 13.5k|#define yytext_ptr yytext_r
------------------
1318| |
1319| 237M| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1319:15): [True: 237M, False: 13.5k]
------------------
1320| 237M| *(dest++) = *(source++);
1321| |
1322| 13.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 510| 13.5k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1322:7): [True: 2.30k, False: 11.2k]
------------------
1323| | /* don't do the read, it's not guaranteed to return an EOF,
1324| | * just force an EOF
1325| | */
1326| 2.30k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 2.30k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1327| |
1328| 11.2k| else
1329| 11.2k| {
1330| 11.2k| int num_to_read =
1331| 11.2k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 11.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1332| |
1333| 11.3k| while ( num_to_read <= 0 )
------------------
| Branch (1333:11): [True: 84, False: 11.2k]
------------------
1334| 84| { /* Not enough room in the buffer - grow it. */
1335| |
1336| | /* just a shorter name for the current buffer */
1337| 84| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 84|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1338| |
1339| 84| int yy_c_buf_p_offset =
1340| 84| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1341| |
1342| 84| if ( b->yy_is_our_buffer )
------------------
| Branch (1342:9): [True: 84, False: 0]
------------------
1343| 84| {
1344| 84| int new_size = b->yy_buf_size * 2;
1345| |
1346| 84| if ( new_size <= 0 )
------------------
| Branch (1346:10): [True: 0, False: 84]
------------------
1347| 0| b->yy_buf_size += b->yy_buf_size / 8;
1348| 84| else
1349| 84| b->yy_buf_size *= 2;
1350| |
1351| 84| b->yy_ch_buf = (char *)
1352| | /* Include room in for 2 EOB chars. */
1353| 84| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 84|#define yyrealloc igraph_lgl_yyrealloc
------------------
1354| 84| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1355| 84| }
1356| 0| else
1357| | /* Can't grow it, we don't own it. */
1358| 0| b->yy_ch_buf = NULL;
1359| |
1360| 84| if ( ! b->yy_ch_buf )
------------------
| Branch (1360:9): [True: 0, False: 84]
------------------
1361| 84| YY_FATAL_ERROR(
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1362| 84| "fatal error - scanner input buffer overflow" );
1363| |
1364| 84| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1365| |
1366| 84| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 84|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1367| 84| number_to_move - 1;
1368| |
1369| 84| }
1370| |
1371| 11.2k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 895| 11.2k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1371:8): [True: 10.6k, False: 677]
------------------
1372| 10.6k| num_to_read = YY_READ_BUF_SIZE;
------------------
| | 895| 10.6k|#define YY_READ_BUF_SIZE 8192
------------------
1373| |
1374| | /* Read in more data. */
1375| 11.2k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 912| 11.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 11.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (912:7): [True: 0, False: 11.2k]
| | ------------------
| | 913| 11.2k| { \
| | 914| 0| int c = '*'; \
| | 915| 0| int n; \
| | 916| 0| for ( n = 0; n < max_size && \
| | ------------------
| | | Branch (916:16): [True: 0, False: 0]
| | ------------------
| | 917| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (917:9): [True: 0, False: 0]
| | | Branch (917:38): [True: 0, False: 0]
| | ------------------
| | 918| 0| buf[n] = (char) c; \
| | 919| 0| if ( c == '\n' ) \
| | ------------------
| | | Branch (919:8): [True: 0, False: 0]
| | ------------------
| | 920| 0| buf[n++] = (char) c; \
| | 921| 0| if ( c == EOF && ferror( yyin ) ) \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (921:8): [True: 0, False: 0]
| | | Branch (921:20): [True: 0, False: 0]
| | ------------------
| | 922| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \
| | ------------------
| | | | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | | | ------------------
| | | | | | 895| 0| do { \
| | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | | | 897| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (897:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 923| 0| result = n; \
| | 924| 0| } \
| | 925| 11.2k| else \
| | 926| 11.2k| { \
| | 927| 11.2k| errno=0; \
| | 928| 11.2k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 11.2k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.19k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (928:11): [True: 3.19k, False: 8.09k]
| | | Branch (928:78): [True: 0, False: 3.19k]
| | ------------------
| | 929| 11.2k| { \
| | 930| 0| if( errno != EINTR) \
| | ------------------
| | | Branch (930:8): [True: 0, False: 0]
| | ------------------
| | 931| 0| { \
| | 932| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \
| | ------------------
| | | | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | | | ------------------
| | | | | | 895| 0| do { \
| | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | | | 897| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (897:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 933| 0| break; \
| | 934| 0| } \
| | 935| 0| errno=0; \
| | 936| 0| clearerr(yyin); \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | 937| 0| } \
| | 938| 11.2k| }\
------------------
1376| 11.2k| yyg->yy_n_chars, num_to_read );
1377| |
1378| 11.2k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 11.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1379| 11.2k| }
1380| |
1381| 13.5k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1381:7): [True: 5.49k, False: 8.09k]
------------------
1382| 5.49k| {
1383| 5.49k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 681| 5.49k|#define YY_MORE_ADJ 0
------------------
| Branch (1383:8): [True: 3.19k, False: 2.30k]
------------------
1384| 3.19k| {
1385| 3.19k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.19k|#define EOB_ACT_END_OF_FILE 1
------------------
1386| 3.19k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.19k|#define yyrestart igraph_lgl_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.19k|#define yyin yyg->yyin_r
------------------
1387| 3.19k| }
1388| |
1389| 2.30k| else
1390| 2.30k| {
1391| 2.30k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 2.30k|#define EOB_ACT_LAST_MATCH 2
------------------
1392| 2.30k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 2.30k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1393| 2.30k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 2.30k|#define YY_BUFFER_EOF_PENDING 2
------------------
1394| 2.30k| }
1395| 5.49k| }
1396| |
1397| 8.09k| else
1398| 8.09k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 8.09k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1399| |
1400| 13.5k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1400:6): [True: 0, False: 13.5k]
------------------
1401| | /* Extend the array by 50%, plus the number we really need. */
1402| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1403| 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_lgl_yyrealloc
------------------
1404| 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]
------------------
1405| 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 (1405:8): [True: 0, False: 0]
------------------
1406| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1407| | /* "- 2" to take care of EOB's */
1408| 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]
------------------
1409| 0| }
1410| |
1411| 13.5k| yyg->yy_n_chars += number_to_move;
1412| 13.5k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 13.5k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1413| 13.5k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 13.5k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1414| |
1415| 13.5k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 13.5k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 13.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1416| |
1417| 13.5k| return ret_val;
1418| 13.5k|}
lgl-lexer.c:yy_get_previous_state:
1423| 10.3k|{
1424| 10.3k| yy_state_type yy_current_state;
1425| 10.3k| char *yy_cp;
1426| 10.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1427| |
1428| 10.3k| yy_current_state = yyg->yy_start;
1429| |
1430| 237M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 579| 10.3k|#define yytext_ptr yytext_r
------------------
for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 681| 10.3k|#define YY_MORE_ADJ 0
------------------
| Branch (1430:47): [True: 237M, False: 10.3k]
------------------
1431| 237M| {
1432| 237M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
------------------
| | 346| 237M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1432:19): [True: 237M, False: 0]
------------------
1433| 237M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1433:8): [True: 237M, False: 8.05k]
------------------
1434| 237M| {
1435| 237M| yyg->yy_last_accepting_state = yy_current_state;
1436| 237M| yyg->yy_last_accepting_cpos = yy_cp;
1437| 237M| }
1438| 475M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1438:11): [True: 237M, False: 237M]
------------------
1439| 237M| {
1440| 237M| yy_current_state = (int) yy_def[yy_current_state];
1441| 237M| if ( yy_current_state >= 16 )
------------------
| Branch (1441:9): [True: 237M, False: 3.89k]
------------------
1442| 237M| yy_c = yy_meta[yy_c];
1443| 237M| }
1444| 237M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1445| 237M| }
1446| |
1447| 10.3k| return yy_current_state;
1448| 10.3k|}
lgl-lexer.c:igraph_lgl_yy_load_buffer_state:
1622| 9.57k|{
1623| 9.57k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1624| 9.57k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 9.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1625| 9.57k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 9.57k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 9.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1626| 9.57k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 9.57k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 9.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1627| 9.57k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1628| 9.57k|}
lgl-lexer.c:igraph_lgl_yy_init_buffer:
1686| 6.38k|{
1687| 6.38k| int oerrno = errno;
1688| 6.38k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1689| |
1690| 6.38k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 6.38k|#define yy_flush_buffer igraph_lgl_yy_flush_buffer
------------------
1691| |
1692| 6.38k| b->yy_input_file = file;
1693| 6.38k| b->yy_fill_buffer = 1;
1694| |
1695| | /* If b is the current buffer, then yy_init_buffer was _probably_
1696| | * called from yyrestart() or through yy_get_next_buffer.
1697| | * In that case, we don't want to reset the lineno or column.
1698| | */
1699| 6.38k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 6.38k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.38k, False: 0]
| | ------------------
| | 522| 6.38k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.38k| : NULL)
------------------
| Branch (1699:9): [True: 3.19k, False: 3.19k]
------------------
1700| 3.19k| b->yy_bs_lineno = 1;
1701| 3.19k| b->yy_bs_column = 0;
1702| 3.19k| }
1703| |
1704| 6.38k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1704:32): [True: 6.38k, False: 0]
------------------
1705| |
1706| | errno = oerrno;
1707| 6.38k|}
lgl-lexer.c:igraph_lgl_yyensure_buffer_stack:
1795| 3.19k|{
1796| 3.19k| yy_size_t num_to_alloc;
1797| 3.19k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1798| |
1799| 3.19k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1799:6): [True: 3.19k, False: 0]
------------------
1800| |
1801| | /* First allocation is just for 2 elements, since we don't know if this
1802| | * scanner will even need a stack. We use 2 instead of 1 to avoid an
1803| | * immediate realloc on the next call.
1804| | */
1805| 3.19k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1806| 3.19k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.19k|#define yyalloc igraph_lgl_yyalloc
------------------
1807| 3.19k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1808| 3.19k| , yyscanner);
1809| 3.19k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1809:8): [True: 0, False: 3.19k]
------------------
1810| 3.19k| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1811| |
1812| 3.19k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1813| |
1814| 3.19k| yyg->yy_buffer_stack_max = num_to_alloc;
1815| 3.19k| yyg->yy_buffer_stack_top = 0;
1816| 3.19k| return;
1817| 3.19k| }
1818| |
1819| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
------------------
| Branch (1819:6): [True: 0, False: 0]
------------------
1820| |
1821| | /* Increase the buffer to prepare for a possible push. */
1822| 0| yy_size_t grow_size = 8 /* arbitrary grow size */;
1823| |
1824| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1825| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
------------------
| | 242| 0|#define yyrealloc igraph_lgl_yyrealloc
------------------
1826| 0| (yyg->yy_buffer_stack,
1827| 0| num_to_alloc * sizeof(struct yy_buffer_state*)
1828| 0| , yyscanner);
1829| 0| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1829:8): [True: 0, False: 0]
------------------
1830| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1831| |
1832| | /* zero only the new slots.*/
1833| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1834| 0| yyg->yy_buffer_stack_max = num_to_alloc;
1835| 0| }
1836| 0|}
lgl-lexer.c:yy_init_globals:
2184| 6.38k|{
2185| 6.38k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2186| | /* Initialization is the same as for the non-reentrant scanner.
2187| | * This function is called from yylex_destroy(), so don't allocate here.
2188| | */
2189| |
2190| 6.38k| yyg->yy_buffer_stack = NULL;
2191| 6.38k| yyg->yy_buffer_stack_top = 0;
2192| 6.38k| yyg->yy_buffer_stack_max = 0;
2193| 6.38k| yyg->yy_c_buf_p = NULL;
2194| 6.38k| yyg->yy_init = 0;
2195| 6.38k| yyg->yy_start = 0;
2196| |
2197| 6.38k| yyg->yy_start_stack_ptr = 0;
2198| 6.38k| yyg->yy_start_stack_depth = 0;
2199| 6.38k| yyg->yy_start_stack = NULL;
2200| |
2201| |/* Defined in main.c */
2202| |#ifdef YY_STDINIT
2203| | yyin = stdin;
2204| | yyout = stdout;
2205| |#else
2206| 6.38k| yyin = NULL;
------------------
| | 356| 6.38k|#define yyin yyg->yyin_r
------------------
2207| 6.38k| yyout = NULL;
------------------
| | 357| 6.38k|#define yyout yyg->yyout_r
------------------
2208| 6.38k|#endif
2209| |
2210| | /* For future reference: Set errno on error, since we are called by
2211| | * yylex_init()
2212| | */
2213| 6.38k| return 0;
2214| 6.38k|}
igraph_lgl_yyparse:
1189| 3.19k|{
1190| |/* The lookahead symbol. */
1191| 3.19k|int yychar;
1192| |
1193| |
1194| |/* The semantic value of the lookahead symbol. */
1195| |/* Default value used for initialization, for pacifying older GCCs
1196| | or non-GCC compilers. */
1197| 3.19k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 358| 3.19k|# define YY_INITIAL_VALUE(Value) Value
------------------
1198| 3.19k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 358| 3.19k|# define YY_INITIAL_VALUE(Value) Value
------------------
1199| |
1200| |/* Location data for the lookahead symbol. */
1201| 3.19k|static YYLTYPE yyloc_default
1202| 3.19k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1203| 3.19k| = { 1, 1, 1, 1 }
1204| 3.19k|# endif
1205| 3.19k|;
1206| 3.19k|YYLTYPE yylloc = yyloc_default;
1207| |
1208| | /* Number of syntax errors so far. */
1209| 3.19k| int yynerrs;
1210| |
1211| 3.19k| yy_state_fast_t yystate;
1212| | /* Number of tokens to shift before error messages enabled. */
1213| 3.19k| int yyerrstatus;
1214| |
1215| | /* The stacks and their tools:
1216| | 'yyss': related to states.
1217| | 'yyvs': related to semantic values.
1218| | 'yyls': related to locations.
1219| |
1220| | Refer to the stacks through separate pointers, to allow yyoverflow
1221| | to reallocate them elsewhere. */
1222| |
1223| | /* The state stack. */
1224| 3.19k| yy_state_t yyssa[YYINITDEPTH];
1225| 3.19k| yy_state_t *yyss;
1226| 3.19k| yy_state_t *yyssp;
1227| |
1228| | /* The semantic value stack. */
1229| 3.19k| YYSTYPE yyvsa[YYINITDEPTH];
1230| 3.19k| YYSTYPE *yyvs;
1231| 3.19k| YYSTYPE *yyvsp;
1232| |
1233| | /* The location stack. */
1234| 3.19k| YYLTYPE yylsa[YYINITDEPTH];
1235| 3.19k| YYLTYPE *yyls;
1236| 3.19k| YYLTYPE *yylsp;
1237| |
1238| | /* The locations where the error started and ended. */
1239| 3.19k| YYLTYPE yyerror_range[3];
1240| |
1241| 3.19k| YYPTRDIFF_T yystacksize;
------------------
| | 273| 3.19k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1242| |
1243| 3.19k| int yyn;
1244| 3.19k| int yyresult;
1245| | /* Lookahead token as an internal (translated) token number. */
1246| 3.19k| int yytoken = 0;
1247| | /* The variables used to return semantic value and location from the
1248| | action routines. */
1249| 3.19k| YYSTYPE yyval;
1250| 3.19k| YYLTYPE yyloc;
1251| |
1252| 3.19k|#if YYERROR_VERBOSE
1253| | /* Buffer for error messages, and its allocated size. */
1254| 3.19k| char yymsgbuf[128];
1255| 3.19k| char *yymsg = yymsgbuf;
1256| 3.19k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 273| 3.19k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1257| 3.19k|#endif
1258| |
1259| 3.19k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1260| |
1261| | /* The number of symbols on the RHS of the reduced rule.
1262| | Keep to zero when no symbol should be popped. */
1263| 3.19k| int yylen = 0;
1264| |
1265| 3.19k| yyssp = yyss = yyssa;
1266| 3.19k| yyvsp = yyvs = yyvsa;
1267| 3.19k| yylsp = yyls = yylsa;
1268| 3.19k| yystacksize = YYINITDEPTH;
------------------
| | 914| 3.19k|# define YYINITDEPTH 200
------------------
1269| |
1270| 3.19k| YYDPRINTF ((stderr, "Starting parse\n"));
1271| |
1272| 3.19k| yystate = 0;
1273| 3.19k| yyerrstatus = 0;
1274| 3.19k| yynerrs = 0;
------------------
| | 71| 3.19k|#define yynerrs igraph_lgl_yynerrs
------------------
1275| 3.19k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 678| 3.19k|#define YYEMPTY (-2)
------------------
1276| 3.19k| yylsp[0] = yylloc;
1277| 3.19k| goto yysetstate;
1278| |
1279| |
1280| |/*------------------------------------------------------------.
1281| || yynewstate -- push a new state, which is found in yystate. |
1282| |`------------------------------------------------------------*/
1283| 2.00M|yynewstate:
1284| | /* In all cases, when you get here, the value and location stacks
1285| | have just been pushed. So pushing a state here evens the stacks. */
1286| 2.00M| yyssp++;
1287| |
1288| |
1289| |/*--------------------------------------------------------------------.
1290| || yysetstate -- set current state (the top of the stack) to yystate. |
1291| |`--------------------------------------------------------------------*/
1292| 2.01M|yysetstate:
1293| 2.01M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1294| 2.01M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 381| 2.01M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (381:31): [Folded, False: 2.01M]
| | | Branch (381:37): [True: 0, False: 0]
| | | Branch (381:37): [True: 0, False: 0]
| | ------------------
------------------
1295| 2.01M| YY_IGNORE_USELESS_CAST_BEGIN
1296| 2.01M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 124| 2.01M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1297| 2.01M| YY_IGNORE_USELESS_CAST_END
1298| |
1299| 2.01M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1299:7): [True: 0, False: 2.01M]
------------------
1300| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1301| | goto yyexhaustedlab;
1302| |#else
1303| 0| {
1304| | /* Get the current used size of the three stacks, in elements. */
1305| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1;
------------------
| | 273| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1306| |
1307| |# if defined yyoverflow
1308| | {
1309| | /* Give user a chance to reallocate the stack. Use copies of
1310| | these so that the &'s don't force the real ones into
1311| | memory. */
1312| | yy_state_t *yyss1 = yyss;
1313| | YYSTYPE *yyvs1 = yyvs;
1314| | YYLTYPE *yyls1 = yyls;
1315| |
1316| | /* Each stack pointer address is followed by the size of the
1317| | data in use in that stack, in bytes. This used to be a
1318| | conditional around just the two extra args, but that might
1319| | be undefined if yyoverflow is a macro. */
1320| | yyoverflow (YY_("memory exhausted"),
1321| | &yyss1, yysize * YYSIZEOF (*yyssp),
1322| | &yyvs1, yysize * YYSIZEOF (*yyvsp),
1323| | &yyls1, yysize * YYSIZEOF (*yylsp),
1324| | &yystacksize);
1325| | yyss = yyss1;
1326| | yyvs = yyvs1;
1327| | yyls = yyls1;
1328| | }
1329| |# else /* defined YYSTACK_RELOCATE */
1330| | /* Extend the stack our own way. */
1331| 0| if (YYMAXDEPTH <= yystacksize)
------------------
| | 925| 0|# define YYMAXDEPTH 10000
------------------
| Branch (1331:11): [True: 0, False: 0]
------------------
1332| 0| goto yyexhaustedlab;
1333| 0| yystacksize *= 2;
1334| 0| if (YYMAXDEPTH < yystacksize)
------------------
| | 925| 0|# define YYMAXDEPTH 10000
------------------
| Branch (1334:11): [True: 0, False: 0]
------------------
1335| 0| yystacksize = YYMAXDEPTH;
------------------
| | 925| 0|# define YYMAXDEPTH 10000
------------------
1336| |
1337| 0| {
1338| 0| yy_state_t *yyss1 = yyss;
1339| 0| union yyalloc *yyptr =
1340| 0| YY_CAST (union yyalloc *,
------------------
| | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1341| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1342| 0| if (! yyptr)
------------------
| Branch (1342:13): [True: 0, False: 0]
------------------
1343| 0| goto yyexhaustedlab;
1344| 0| YYSTACK_RELOCATE (yyss_alloc, yyss);
------------------
| | 482| 0| do \
| | 483| 0| { \
| | 484| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 273| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 485| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 500| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 486| 0| Stack = &yyptr->Stack_alloc; \
| | 487| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 465| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 488| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 489| 0| } \
| | 490| 0| while (0)
| | ------------------
| | | Branch (490:12): [Folded, False: 0]
| | ------------------
------------------
1345| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs);
------------------
| | 482| 0| do \
| | 483| 0| { \
| | 484| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 273| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 485| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 500| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 486| 0| Stack = &yyptr->Stack_alloc; \
| | 487| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 465| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 488| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 489| 0| } \
| | 490| 0| while (0)
| | ------------------
| | | Branch (490:12): [Folded, False: 0]
| | ------------------
------------------
1346| 0| YYSTACK_RELOCATE (yyls_alloc, yyls);
------------------
| | 482| 0| do \
| | 483| 0| { \
| | 484| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 273| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 485| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 500| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 486| 0| Stack = &yyptr->Stack_alloc; \
| | 487| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 465| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 488| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 489| 0| } \
| | 490| 0| while (0)
| | ------------------
| | | Branch (490:12): [Folded, False: 0]
| | ------------------
------------------
1347| 0|# undef YYSTACK_RELOCATE
1348| 0| if (yyss1 != yyssa)
------------------
| Branch (1348:13): [True: 0, False: 0]
------------------
1349| 0| YYSTACK_FREE (yyss1);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1350| 0| }
1351| 0|# endif
1352| |
1353| 0| yyssp = yyss + yysize - 1;
1354| 0| yyvsp = yyvs + yysize - 1;
1355| 0| yylsp = yyls + yysize - 1;
1356| |
1357| 0| YY_IGNORE_USELESS_CAST_BEGIN
1358| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1359| 0| YY_CAST (long, yystacksize)));
1360| 0| YY_IGNORE_USELESS_CAST_END
1361| |
1362| 0| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1362:11): [True: 0, False: 0]
------------------
1363| 0| YYABORT;
------------------
| | 682| 0|#define YYABORT goto yyabortlab
------------------
1364| 0| }
1365| 2.01M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1366| |
1367| 2.01M| if (yystate == YYFINAL)
------------------
| | 515| 2.01M|#define YYFINAL 2
------------------
| Branch (1367:7): [True: 3.19k, False: 2.00M]
------------------
1368| 3.19k| YYACCEPT;
------------------
| | 681| 3.19k|#define YYACCEPT goto yyacceptlab
------------------
1369| |
1370| 2.00M| goto yybackup;
1371| |
1372| |
1373| |/*-----------.
1374| || yybackup. |
1375| |`-----------*/
1376| 2.00M|yybackup:
1377| | /* Do appropriate processing given the current state. Read a
1378| | lookahead token if we need one and don't already have one. */
1379| |
1380| | /* First try to decide what to do without reference to lookahead token. */
1381| 2.00M| yyn = yypact[yystate];
1382| 2.00M| if (yypact_value_is_default (yyn))
------------------
| | 602| 2.00M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 599| 2.00M|#define YYPACT_NINF (-3)
| | ------------------
| | | Branch (602:3): [True: 1.17M, False: 833k]
| | ------------------
------------------
1383| 1.17M| goto yydefault;
1384| |
1385| | /* Not known => get a lookahead token if don't already have one. */
1386| |
1387| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1388| 833k| if (yychar == YYEMPTY)
------------------
| | 678| 833k|#define YYEMPTY (-2)
------------------
| Branch (1388:7): [True: 820k, False: 12.9k]
------------------
1389| 820k| {
1390| 820k| YYDPRINTF ((stderr, "Reading a token: "));
1391| 820k| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 820k|#define yylex igraph_lgl_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 115| 820k|#define scanner context->scanner
------------------
1392| 820k| }
1393| |
1394| 833k| if (yychar <= YYEOF)
------------------
| | 679| 833k|#define YYEOF 0
------------------
| Branch (1394:7): [True: 5.49k, False: 828k]
------------------
1395| 5.49k| {
1396| 5.49k| yychar = yytoken = YYEOF;
------------------
| | 679| 5.49k|#define YYEOF 0
------------------
1397| 5.49k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1398| 5.49k| }
1399| 828k| else
1400| 828k| {
1401| 828k| yytoken = YYTRANSLATE (yychar);
------------------
| | 535| 828k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 828k|#define YYMAXUTOK 261
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 828k, False: 0]
| | | Branch (535:18): [True: 828k, False: 0]
| | ------------------
------------------
1402| 828k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1403| 828k| }
1404| |
1405| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1406| | detect an error, take that action. */
1407| 833k| yyn += yytoken;
1408| 833k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 517| 833k|#define YYLAST 10
------------------
| Branch (1408:7): [True: 0, False: 833k]
| Branch (1408:18): [True: 0, False: 833k]
| Branch (1408:34): [True: 12.9k, False: 820k]
------------------
1409| 12.9k| goto yydefault;
1410| 820k| yyn = yytable[yyn];
1411| 820k| if (yyn <= 0)
------------------
| Branch (1411:7): [True: 0, False: 820k]
------------------
1412| 0| {
1413| 0| if (yytable_value_is_error (yyn))
------------------
| | 607| 0| 0
| | ------------------
| | | Branch (607:3): [Folded, False: 0]
| | ------------------
------------------
1414| 0| goto yyerrlab;
1415| 0| yyn = -yyn;
1416| 0| goto yyreduce;
1417| 0| }
1418| |
1419| | /* Count tokens shifted since error; after three, turn off error
1420| | status. */
1421| 820k| if (yyerrstatus)
------------------
| Branch (1421:7): [True: 0, False: 820k]
------------------
1422| 0| yyerrstatus--;
1423| |
1424| | /* Shift the lookahead token. */
1425| 820k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1426| 820k| yystate = yyn;
1427| 820k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1428| 820k| *++yyvsp = yylval;
1429| 820k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1430| 820k| *++yylsp = yylloc;
1431| |
1432| | /* Discard the shifted token. */
1433| 820k| yychar = YYEMPTY;
------------------
| | 678| 820k|#define YYEMPTY (-2)
------------------
1434| 820k| goto yynewstate;
1435| |
1436| |
1437| |/*-----------------------------------------------------------.
1438| || yydefault -- do the default action for the current state. |
1439| |`-----------------------------------------------------------*/
1440| 1.18M|yydefault:
1441| 1.18M| yyn = yydefact[yystate];
1442| 1.18M| if (yyn == 0)
------------------
| Branch (1442:7): [True: 0, False: 1.18M]
------------------
1443| 0| goto yyerrlab;
1444| 1.18M| goto yyreduce;
1445| |
1446| |
1447| |/*-----------------------------.
1448| || yyreduce -- do a reduction. |
1449| |`-----------------------------*/
1450| 1.18M|yyreduce:
1451| | /* yyn is the number of a rule to reduce with. */
1452| 1.18M| yylen = yyr2[yyn];
1453| |
1454| | /* If YYLEN is nonzero, implement the default value of the action:
1455| | '$$ = $1'.
1456| |
1457| | Otherwise, the following line sets YYVAL to garbage.
1458| | This behavior is undocumented and Bison
1459| | users should not rely upon it. Assigning to YYVAL
1460| | unconditionally makes the parser a bit smaller, and it avoids a
1461| | GCC warning that YYVAL may be used uninitialized. */
1462| 1.18M| yyval = yyvsp[1-yylen];
1463| |
1464| | /* Default location. */
1465| 1.18M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 716| 1.18M| do \
| | 717| 1.18M| if (N) \
| | ------------------
| | | Branch (717:11): [True: 1.17M, False: 16.1k]
| | ------------------
| | 718| 1.18M| { \
| | 719| 1.17M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 734| 1.17M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 720| 1.17M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 734| 1.17M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 721| 1.17M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 734| 1.17M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 722| 1.17M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 734| 1.17M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 723| 1.17M| } \
| | 724| 1.18M| else \
| | 725| 1.18M| { \
| | 726| 16.1k| (Current).first_line = (Current).last_line = \
| | 727| 16.1k| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 734| 16.1k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 728| 16.1k| (Current).first_column = (Current).last_column = \
| | 729| 16.1k| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 734| 16.1k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 730| 16.1k| } \
| | 731| 1.18M| while (0)
| | ------------------
| | | Branch (731:12): [Folded, False: 1.18M]
| | ------------------
------------------
1466| 1.18M| yyerror_range[1] = yyloc;
1467| 1.18M| YY_REDUCE_PRINT (yyn);
1468| 1.18M| switch (yyn)
1469| 1.18M| {
1470| 12.9k| case 6:
------------------
| Branch (1470:3): [True: 12.9k, False: 1.17M]
------------------
1471| 12.9k|#line 99 "/src/igraph/src/io/lgl-parser.y"
1472| 12.9k| { context->actvertex=(yyvsp[-1].edgenum); }
1473| 12.9k|#line 1474 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1474| 12.9k| break;
1475| |
1476| 247k| case 9:
------------------
| Branch (1476:3): [True: 247k, False: 941k]
------------------
1477| 247k|#line 103 "/src/igraph/src/io/lgl-parser.y"
1478| 247k| {
1479| 247k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, context->actvertex));
------------------
| | 10| 247k| do { \
| | 11| 247k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 247k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 247k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 247k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_lgl_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 682| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 247k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 247k]
| | ------------------
------------------
1480| 247k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-1].edgenum)));
------------------
| | 10| 247k| do { \
| | 11| 247k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 247k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 247k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 247k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_lgl_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 682| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 247k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 247k]
| | ------------------
------------------
1481| 247k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, 1.0));
------------------
| | 10| 247k| do { \
| | 11| 247k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 247k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 247k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 247k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_lgl_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 682| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 247k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 247k]
| | ------------------
------------------
1482| 247k| }
1483| 247k|#line 1484 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1484| 247k| break;
1485| |
1486| 247k| case 10:
------------------
| Branch (1486:3): [True: 94.7k, False: 1.09M]
------------------
1487| 94.7k|#line 108 "/src/igraph/src/io/lgl-parser.y"
1488| 94.7k| {
1489| 94.7k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, context->actvertex));
------------------
| | 10| 94.7k| do { \
| | 11| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_lgl_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 682| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 94.7k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 94.7k]
| | ------------------
------------------
1490| 94.7k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-2].edgenum)));
------------------
| | 10| 94.7k| do { \
| | 11| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_lgl_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 682| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 94.7k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 94.7k]
| | ------------------
------------------
1491| 94.7k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, (yyvsp[-1].weightnum)));
------------------
| | 10| 94.7k| do { \
| | 11| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_lgl_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 682| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 94.7k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 94.7k]
| | ------------------
------------------
1492| 94.7k| context->has_weights = 1;
1493| 94.7k| }
1494| 0|#line 1495 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1495| 0| break;
1496| |
1497| 354k| case 11:
------------------
| Branch (1497:3): [True: 354k, False: 833k]
------------------
1498| 354k|#line 117 "/src/igraph/src/io/lgl-parser.y"
1499| 354k| {
1500| 354k| igraph_int_t trie_id;
1501| 354k| IGRAPH_YY_CHECK(igraph_trie_get_len(context->trie,
------------------
| | 10| 354k| do { \
| | 11| 354k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 354k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 354k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 354k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_lgl_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 682| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 354k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 354k]
| | ------------------
------------------
1502| 354k| igraph_lgl_yyget_text(scanner),
1503| 354k| igraph_lgl_yyget_leng(scanner),
1504| 354k| &trie_id
1505| 354k| ));
1506| 354k| (yyval.edgenum) = trie_id;
1507| 354k|}
1508| 0|#line 1509 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1509| 0| break;
1510| |
1511| 94.7k| case 12:
------------------
| Branch (1511:3): [True: 94.7k, False: 1.09M]
------------------
1512| 94.7k|#line 127 "/src/igraph/src/io/lgl-parser.y"
1513| 94.7k| {
1514| 94.7k| igraph_real_t val;
1515| 94.7k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_lgl_yyget_text(scanner),
------------------
| | 10| 94.7k| do { \
| | 11| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_lgl_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 682| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 94.7k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 94.7k]
| | ------------------
------------------
1516| 94.7k| igraph_lgl_yyget_leng(scanner),
1517| 94.7k| &val));
1518| 94.7k| (yyval.weightnum)=val;
1519| 94.7k|}
1520| 0|#line 1521 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1521| 0| break;
1522| |
1523| |
1524| 0|#line 1525 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1525| |
1526| 384k| default: break;
------------------
| Branch (1526:7): [True: 384k, False: 804k]
------------------
1527| 1.18M| }
1528| | /* User semantic actions sometimes alter yychar, and that requires
1529| | that yytoken be updated with the new translation. We take the
1530| | approach of translating immediately before every use of yytoken.
1531| | One alternative is translating here after every semantic action,
1532| | but that translation would be missed if the semantic action invokes
1533| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1534| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1535| | incorrect destructor might then be invoked immediately. In the
1536| | case of YYERROR or YYBACKUP, subsequent parser actions might lead
1537| | to an incorrect destructor call or verbose syntax error message
1538| | before the lookahead is translated. */
1539| 1.18M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1540| |
1541| 1.18M| YYPOPSTACK (yylen);
------------------
| | 1259| 1.18M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1542| 1.18M| yylen = 0;
1543| 1.18M| YY_STACK_PRINT (yyss, yyssp);
1544| |
1545| 1.18M| *++yyvsp = yyval;
1546| 1.18M| *++yylsp = yyloc;
1547| |
1548| | /* Now 'shift' the result of the reduction. Determine what state
1549| | that goes to, based on the state we popped back to and the rule
1550| | number reduced by. */
1551| 1.18M| {
1552| 1.18M| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 520| 1.18M|#define YYNTOKENS 7
------------------
1553| 1.18M| const int yyi = yypgoto[yylhs] + *yyssp;
1554| 1.18M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 517| 2.33M|#define YYLAST 10
------------------
| Branch (1554:16): [True: 1.14M, False: 41.9k]
| Branch (1554:28): [True: 1.14M, False: 0]
| Branch (1554:45): [True: 342k, False: 804k]
------------------
1555| 1.18M| ? yytable[yyi]
1556| 1.18M| : yydefgoto[yylhs]);
1557| 1.18M| }
1558| |
1559| 1.18M| goto yynewstate;
1560| |
1561| |
1562| |/*--------------------------------------.
1563| || yyerrlab -- here on detecting error. |
1564| |`--------------------------------------*/
1565| 0|yyerrlab:
1566| | /* Make sure we have latest lookahead translation. See comments at
1567| | user semantic actions for why this is necessary. */
1568| 0| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 678| 0|#define YYEMPTY (-2)
------------------
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 678| 0|#define YYEMPTY (-2)
------------------
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 535| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 0|#define YYMAXUTOK 261
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 0, False: 0]
| | | Branch (535:18): [True: 0, False: 0]
| | ------------------
------------------
| Branch (1568:13): [True: 0, False: 0]
------------------
1569| |
1570| | /* If not already recovering from an error, report this error. */
1571| 0| if (!yyerrstatus)
------------------
| Branch (1571:7): [True: 0, False: 0]
------------------
1572| 0| {
1573| 0| ++yynerrs;
------------------
| | 71| 0|#define yynerrs igraph_lgl_yynerrs
------------------
1574| |#if ! YYERROR_VERBOSE
1575| | yyerror (&yylloc, context, YY_("syntax error"));
1576| |#else
1577| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1578| 0| yyssp, yytoken)
1579| 0| {
1580| 0| char const *yymsgp = YY_("syntax error");
------------------
| | 322| 0|# define YY_(Msgid) Msgid
------------------
1581| 0| int yysyntax_error_status;
1582| 0| yysyntax_error_status = YYSYNTAX_ERROR;
------------------
| | 1577| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
| | 1578| 0| yyssp, yytoken)
------------------
1583| 0| if (yysyntax_error_status == 0)
------------------
| Branch (1583:13): [True: 0, False: 0]
------------------
1584| 0| yymsgp = yymsg;
1585| 0| else if (yysyntax_error_status == 1)
------------------
| Branch (1585:18): [True: 0, False: 0]
------------------
1586| 0| {
1587| 0| if (yymsg != yymsgbuf)
------------------
| Branch (1587:17): [True: 0, False: 0]
------------------
1588| 0| YYSTACK_FREE (yymsg);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1589| 0| yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
------------------
| | 124| 0|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1590| 0| if (!yymsg)
------------------
| Branch (1590:17): [True: 0, False: 0]
------------------
1591| 0| {
1592| 0| yymsg = yymsgbuf;
1593| 0| yymsg_alloc = sizeof yymsgbuf;
1594| 0| yysyntax_error_status = 2;
1595| 0| }
1596| 0| else
1597| 0| {
1598| 0| yysyntax_error_status = YYSYNTAX_ERROR;
------------------
| | 1577| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
| | 1578| 0| yyssp, yytoken)
------------------
1599| 0| yymsgp = yymsg;
1600| 0| }
1601| 0| }
1602| 0| yyerror (&yylloc, context, yymsgp);
------------------
| | 69| 0|#define yyerror igraph_lgl_yyerror
------------------
1603| 0| if (yysyntax_error_status == 2)
------------------
| Branch (1603:13): [True: 0, False: 0]
------------------
1604| 0| goto yyexhaustedlab;
1605| 0| }
1606| 0|# undef YYSYNTAX_ERROR
1607| 0|#endif
1608| 0| }
1609| |
1610| 0| yyerror_range[1] = yylloc;
1611| |
1612| 0| if (yyerrstatus == 3)
------------------
| Branch (1612:7): [True: 0, False: 0]
------------------
1613| 0| {
1614| | /* If just tried and failed to reuse lookahead token after an
1615| | error, discard it. */
1616| |
1617| 0| if (yychar <= YYEOF)
------------------
| | 679| 0|#define YYEOF 0
------------------
| Branch (1617:11): [True: 0, False: 0]
------------------
1618| 0| {
1619| | /* Return failure if at end of input. */
1620| 0| if (yychar == YYEOF)
------------------
| | 679| 0|#define YYEOF 0
------------------
| Branch (1620:15): [True: 0, False: 0]
------------------
1621| 0| YYABORT;
------------------
| | 682| 0|#define YYABORT goto yyabortlab
------------------
1622| 0| }
1623| 0| else
1624| 0| {
1625| 0| yydestruct ("Error: discarding",
1626| 0| yytoken, &yylval, &yylloc, context);
1627| 0| yychar = YYEMPTY;
------------------
| | 678| 0|#define YYEMPTY (-2)
------------------
1628| 0| }
1629| 0| }
1630| |
1631| | /* Else will try to reuse lookahead token after shifting the error
1632| | token. */
1633| 0| goto yyerrlab1;
1634| |
1635| |
1636| |/*---------------------------------------------------.
1637| || yyerrorlab -- error raised explicitly by YYERROR. |
1638| |`---------------------------------------------------*/
1639| 0|yyerrorlab:
1640| | /* Pacify compilers when the user code never invokes YYERROR and the
1641| | label yyerrorlab therefore never appears in user code. */
1642| 0| if (0)
------------------
| Branch (1642:7): [Folded, False: 0]
------------------
1643| 0| YYERROR;
------------------
| | 683| 0|#define YYERROR goto yyerrorlab
------------------
1644| |
1645| | /* Do not reclaim the symbols of the rule whose action triggered
1646| | this YYERROR. */
1647| 0| YYPOPSTACK (yylen);
------------------
| | 1259| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1648| 0| yylen = 0;
1649| 0| YY_STACK_PRINT (yyss, yyssp);
1650| 0| yystate = *yyssp;
1651| 0| goto yyerrlab1;
1652| |
1653| |
1654| |/*-------------------------------------------------------------.
1655| || yyerrlab1 -- common code for both syntax error and YYERROR. |
1656| |`-------------------------------------------------------------*/
1657| 0|yyerrlab1:
1658| 0| yyerrstatus = 3; /* Each real token shifted decrements this. */
1659| |
1660| 0| for (;;)
1661| 0| {
1662| 0| yyn = yypact[yystate];
1663| 0| if (!yypact_value_is_default (yyn))
------------------
| | 602| 0| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 599| 0|#define YYPACT_NINF (-3)
| | ------------------
------------------
| Branch (1663:11): [True: 0, False: 0]
------------------
1664| 0| {
1665| 0| yyn += YYTERROR;
------------------
| | 706| 0|#define YYTERROR 1
------------------
1666| 0| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
------------------
| | 517| 0|#define YYLAST 10
------------------
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
------------------
| | 706| 0|#define YYTERROR 1
------------------
| Branch (1666:15): [True: 0, False: 0]
| Branch (1666:27): [True: 0, False: 0]
| Branch (1666:44): [True: 0, False: 0]
------------------
1667| 0| {
1668| 0| yyn = yytable[yyn];
1669| 0| if (0 < yyn)
------------------
| Branch (1669:19): [True: 0, False: 0]
------------------
1670| 0| break;
1671| 0| }
1672| 0| }
1673| |
1674| | /* Pop the current state because it cannot handle the error token. */
1675| 0| if (yyssp == yyss)
------------------
| Branch (1675:11): [True: 0, False: 0]
------------------
1676| 0| YYABORT;
------------------
| | 682| 0|#define YYABORT goto yyabortlab
------------------
1677| |
1678| 0| yyerror_range[1] = *yylsp;
1679| 0| yydestruct ("Error: popping",
1680| 0| yystos[yystate], yyvsp, yylsp, context);
1681| 0| YYPOPSTACK (1);
------------------
| | 1259| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1682| 0| yystate = *yyssp;
1683| 0| YY_STACK_PRINT (yyss, yyssp);
1684| 0| }
1685| |
1686| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1687| 0| *++yyvsp = yylval;
1688| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END
1689| |
1690| 0| yyerror_range[2] = yylloc;
1691| | /* Using YYLLOC is tempting, but would change the location of
1692| | the lookahead. YYLOC is available though. */
1693| 0| YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
------------------
| | 716| 0| do \
| | 717| 0| if (N) \
| | ------------------
| | | Branch (717:11): [True: 0, Folded]
| | ------------------
| | 718| 0| { \
| | 719| 0| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 734| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 720| 0| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 734| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 721| 0| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 734| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 722| 0| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 734| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 723| 0| } \
| | 724| 0| else \
| | 725| 0| { \
| | 726| 0| (Current).first_line = (Current).last_line = \
| | 727| 0| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 734| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 728| 0| (Current).first_column = (Current).last_column = \
| | 729| 0| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 734| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 730| 0| } \
| | 731| 0| while (0)
| | ------------------
| | | Branch (731:12): [Folded, False: 0]
| | ------------------
------------------
1694| 0| *++yylsp = yyloc;
1695| |
1696| | /* Shift the error token. */
1697| 0| YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1698| |
1699| 0| yystate = yyn;
1700| 0| goto yynewstate;
1701| |
1702| |
1703| |/*-------------------------------------.
1704| || yyacceptlab -- YYACCEPT comes here. |
1705| |`-------------------------------------*/
1706| 3.19k|yyacceptlab:
1707| 3.19k| yyresult = 0;
1708| 3.19k| goto yyreturn;
1709| |
1710| |
1711| |/*-----------------------------------.
1712| || yyabortlab -- YYABORT comes here. |
1713| |`-----------------------------------*/
1714| 0|yyabortlab:
1715| 0| yyresult = 1;
1716| 0| goto yyreturn;
1717| |
1718| |
1719| 0|#if !defined yyoverflow || YYERROR_VERBOSE
1720| |/*-------------------------------------------------.
1721| || yyexhaustedlab -- memory exhaustion comes here. |
1722| |`-------------------------------------------------*/
1723| 0|yyexhaustedlab:
1724| 0| yyerror (&yylloc, context, YY_("memory exhausted"));
------------------
| | 69| 0|#define yyerror igraph_lgl_yyerror
------------------
yyerror (&yylloc, context, YY_("memory exhausted"));
------------------
| | 322| 0|# define YY_(Msgid) Msgid
------------------
1725| 0| yyresult = 2;
1726| | /* Fall through. */
1727| 0|#endif
1728| |
1729| |
1730| |/*-----------------------------------------------------.
1731| || yyreturn -- parsing is finished, return the result. |
1732| |`-----------------------------------------------------*/
1733| 3.19k|yyreturn:
1734| 3.19k| if (yychar != YYEMPTY)
------------------
| | 678| 3.19k|#define YYEMPTY (-2)
------------------
| Branch (1734:7): [True: 0, False: 3.19k]
------------------
1735| 0| {
1736| | /* Make sure we have latest lookahead translation. See comments at
1737| | user semantic actions for why this is necessary. */
1738| 0| yytoken = YYTRANSLATE (yychar);
------------------
| | 535| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 0|#define YYMAXUTOK 261
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 0, False: 0]
| | | Branch (535:18): [True: 0, False: 0]
| | ------------------
------------------
1739| 0| yydestruct ("Cleanup: discarding lookahead",
1740| 0| yytoken, &yylval, &yylloc, context);
1741| 0| }
1742| | /* Do not reclaim the symbols of the rule whose action triggered
1743| | this YYABORT or YYACCEPT. */
1744| 3.19k| YYPOPSTACK (yylen);
------------------
| | 1259| 3.19k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1745| 3.19k| YY_STACK_PRINT (yyss, yyssp);
1746| 9.57k| while (yyssp != yyss)
------------------
| Branch (1746:10): [True: 6.38k, False: 3.19k]
------------------
1747| 6.38k| {
1748| 6.38k| yydestruct ("Cleanup: popping",
1749| 6.38k| yystos[+*yyssp], yyvsp, yylsp, context);
1750| 6.38k| YYPOPSTACK (1);
------------------
| | 1259| 6.38k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1751| 6.38k| }
1752| 3.19k|#ifndef yyoverflow
1753| 3.19k| if (yyss != yyssa)
------------------
| Branch (1753:7): [True: 0, False: 3.19k]
------------------
1754| 0| YYSTACK_FREE (yyss);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1755| 3.19k|#endif
1756| 3.19k|#if YYERROR_VERBOSE
1757| 3.19k| if (yymsg != yymsgbuf)
------------------
| Branch (1757:7): [True: 0, False: 3.19k]
------------------
1758| 0| YYSTACK_FREE (yymsg);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1759| 3.19k|#endif
1760| 3.19k| return yyresult;
1761| 0|}
lgl-parser.c:yydestruct:
1167| 6.38k|{
1168| 6.38k| YYUSE (yyvaluep);
------------------
| | 344| 6.38k|# define YYUSE(E) ((void) (E))
------------------
1169| 6.38k| YYUSE (yylocationp);
------------------
| | 344| 6.38k|# define YYUSE(E) ((void) (E))
------------------
1170| 6.38k| YYUSE (context);
------------------
| | 344| 6.38k|# define YYUSE(E) ((void) (E))
------------------
1171| 6.38k| if (!yymsg)
------------------
| Branch (1171:7): [True: 0, False: 6.38k]
------------------
1172| 0| yymsg = "Deleting";
1173| 6.38k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1174| |
1175| 6.38k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1176| 6.38k| YYUSE (yytype);
------------------
| | 344| 6.38k|# define YYUSE(E) ((void) (E))
------------------
1177| 6.38k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1178| 6.38k|}
igraph_ncol_yylex:
994| 1.12M|{
995| 1.12M| yy_state_type yy_current_state;
996| 1.12M| char *yy_cp, *yy_bp;
997| 1.12M| int yy_act;
998| 1.12M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
999| |
1000| 1.12M| yylval = yylval_param;
------------------
| | 807| 1.12M| # define yylval yyg->yylval_r
------------------
1001| |
1002| 1.12M| yylloc = yylloc_param;
------------------
| | 809| 1.12M| # define yylloc yyg->yylloc_r
------------------
1003| |
1004| 1.12M| if ( !yyg->yy_init )
------------------
| Branch (1004:7): [True: 3.24k, False: 1.12M]
------------------
1005| 3.24k| {
1006| 3.24k| yyg->yy_init = 1;
1007| |
1008| |#ifdef YY_USER_INIT
1009| | YY_USER_INIT;
1010| |#endif
1011| |
1012| 3.24k| if ( ! yyg->yy_start )
------------------
| Branch (1012:8): [True: 3.24k, False: 0]
------------------
1013| 3.24k| yyg->yy_start = 1; /* first start state */
1014| |
1015| 3.24k| if ( ! yyin )
------------------
| | 356| 3.24k|#define yyin yyg->yyin_r
------------------
| Branch (1015:8): [True: 0, False: 3.24k]
------------------
1016| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1017| |
1018| 3.24k| if ( ! yyout )
------------------
| | 357| 3.24k|#define yyout yyg->yyout_r
------------------
| Branch (1018:8): [True: 3.24k, False: 0]
------------------
1019| 3.24k| yyout = stdout;
------------------
| | 357| 3.24k|#define yyout yyg->yyout_r
------------------
1020| |
1021| 3.24k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.24k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.24k]
| | ------------------
| | 522| 3.24k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.24k| : NULL)
------------------
| Branch (1021:8): [True: 3.24k, False: 0]
------------------
1022| 3.24k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.24k|#define yyensure_buffer_stack igraph_ncol_yyensure_buffer_stack
------------------
1023| 3.24k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1024| 3.24k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.24k|#define yy_create_buffer igraph_ncol_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.24k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.24k|#define YY_BUF_SIZE 16384
------------------
1025| 3.24k| }
1026| |
1027| 3.24k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.24k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1028| 3.24k| }
1029| |
1030| 1.12M| {
1031| 1.12M|#line 79 "/src/igraph/src/io/ncol-lexer.l"
1032| |
1033| |
1034| 1.12M|#line 82 "/src/igraph/src/io/ncol-lexer.l"
1035| | /* ------------------------------------------------whitespace------*/
1036| 1.12M|#line 1037 "/src/igraph/build/src/io/parsers/ncol-lexer.c"
1037| |
1038| 1.56M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1038:23): [True: 1.56M, Folded]
------------------
1039| 1.56M| {
1040| 1.56M| yy_cp = yyg->yy_c_buf_p;
1041| |
1042| | /* Support of yytext. */
1043| 1.56M| *yy_cp = yyg->yy_hold_char;
1044| |
1045| | /* yy_bp points to the position in yy_ch_buf of the start of
1046| | * the current run.
1047| | */
1048| 1.56M| yy_bp = yy_cp;
1049| |
1050| 1.56M| yy_current_state = yyg->yy_start;
1051| 1.57M|yy_match:
1052| 1.57M| do
1053| 74.8M| {
1054| 74.8M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 74.8M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1055| 74.8M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1055:9): [True: 73.3M, False: 1.56M]
------------------
1056| 73.3M| {
1057| 73.3M| yyg->yy_last_accepting_state = yy_current_state;
1058| 73.3M| yyg->yy_last_accepting_cpos = yy_cp;
1059| 73.3M| }
1060| 150M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1060:12): [True: 76.0M, False: 74.8M]
------------------
1061| 76.0M| {
1062| 76.0M| yy_current_state = (int) yy_def[yy_current_state];
1063| 76.0M| if ( yy_current_state >= 15 )
------------------
| Branch (1063:10): [True: 73.2M, False: 2.79M]
------------------
1064| 73.2M| yy_c = yy_meta[yy_c];
1065| 76.0M| }
1066| 74.8M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1067| 74.8M| ++yy_cp;
1068| 74.8M| }
1069| 74.8M| while ( yy_base[yy_current_state] != 11 );
------------------
| Branch (1069:11): [True: 73.3M, False: 1.57M]
------------------
1070| |
1071| 1.58M|yy_find_action:
1072| 1.58M| yy_act = yy_accept[yy_current_state];
1073| 1.58M| if ( yy_act == 0 )
------------------
| Branch (1073:8): [True: 1.57M, False: 2.36k]
------------------
1074| 1.57M| { /* have to back up */
1075| 1.57M| yy_cp = yyg->yy_last_accepting_cpos;
1076| 1.57M| yy_current_state = yyg->yy_last_accepting_state;
1077| 1.57M| yy_act = yy_accept[yy_current_state];
1078| 1.57M| }
1079| |
1080| 1.58M| YY_DO_BEFORE_ACTION;
------------------
| | 590| 1.58M| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 1.58M|#define yytext_ptr yytext_r
| | ------------------
| | 591| 1.58M| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 1.58M|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 1.58M| yyg->yy_hold_char = *yy_cp; \
| | 593| 1.58M| *yy_cp = '\0'; \
| | 594| 1.58M| yyg->yy_c_buf_p = yy_cp;
------------------
1081| |
1082| 1.58M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 3.16M|#define YY_END_OF_BUFFER 6
------------------
| Branch (1082:8): [True: 1.56M, False: 17.1k]
| Branch (1082:38): [True: 343k, False: 1.22M]
------------------
1083| 343k| {
1084| 343k| int yyl;
1085| 687k| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 687k|#define yyleng yyg->yyleng_r
------------------
| Branch (1085:19): [True: 343k, False: 343k]
------------------
1086| 343k| if ( yytext[yyl] == '\n' )
------------------
| | 360| 343k|#define yytext yyg->yytext_r
------------------
| Branch (1086:10): [True: 343k, False: 0]
------------------
1087| |
1088| 343k| do{ yylineno++;
------------------
| | 361| 343k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 343k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1089| 343k| yycolumn=0;
------------------
| | 362| 343k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 343k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1090| 343k| }while(0)
------------------
| Branch (1090:12): [Folded, False: 343k]
------------------
1091| 343k|;
1092| 343k| }
1093| |
1094| 1.58M|do_action: /* This label is used only to access EOF actions. */
1095| |
1096| 1.58M| switch ( yy_act )
1097| 1.58M| { /* beginning of action switch */
1098| 0| case 0: /* must back up */
------------------
| Branch (1098:4): [True: 0, False: 1.58M]
------------------
1099| | /* undo the effects of YY_DO_BEFORE_ACTION */
1100| 0| *yy_cp = yyg->yy_hold_char;
1101| 0| yy_cp = yyg->yy_last_accepting_cpos;
1102| 0| yy_current_state = yyg->yy_last_accepting_state;
1103| 0| goto yy_find_action;
1104| |
1105| 438k|case 1:
------------------
| Branch (1105:1): [True: 438k, False: 1.14M]
------------------
1106| 438k|YY_RULE_SETUP
------------------
| | 989| 438k| YY_USER_ACTION
| | ------------------
| | | | 735| 438k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 438k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 438k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 438k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1107| 438k|#line 83 "/src/igraph/src/io/ncol-lexer.l"
1108| 438k|{ /* skip space */ }
1109| 438k| YY_BREAK
------------------
| | 985| 438k|#define YY_BREAK /*LINTED*/break;
------------------
1110| |/* ----------------------------------------------alphanumeric------*/
1111| 781k|case 2:
------------------
| Branch (1111:1): [True: 781k, False: 802k]
------------------
1112| 781k|YY_RULE_SETUP
------------------
| | 989| 781k| YY_USER_ACTION
| | ------------------
| | | | 735| 781k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 781k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 781k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 781k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1113| 781k|#line 86 "/src/igraph/src/io/ncol-lexer.l"
1114| 781k|{ BEGIN(LINE); return ALNUM; }
------------------
| | 369| 781k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return ALNUM; }
------------------
| | 751| 781k|#define LINE 1
------------------
1115| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1116| |/* ---------------------------------------------------newline------*/
1117| 343k|case 3:
------------------
| Branch (1117:1): [True: 343k, False: 1.24M]
------------------
1118| |/* rule 3 can match eol */
1119| 343k|#line 90 "/src/igraph/src/io/ncol-lexer.l"
1120| 343k|YY_RULE_SETUP
------------------
| | 989| 343k| YY_USER_ACTION
| | ------------------
| | | | 735| 343k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 343k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 343k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 343k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1121| 343k|case YY_STATE_EOF(LINE):
------------------
| | 377| 343k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 343k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
| Branch (1121:1): [True: 0, False: 1.58M]
------------------
1122| 343k|#line 90 "/src/igraph/src/io/ncol-lexer.l"
1123| 343k|{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 369| 343k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 750| 343k|#define INITIAL 0
------------------
1124| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1125| |/* ---------------------------------------------anything else------*/
1126| 0|case 4:
------------------
| Branch (1126:1): [True: 0, False: 1.58M]
------------------
1127| 0|YY_RULE_SETUP
------------------
| | 989| 0| YY_USER_ACTION
| | ------------------
| | | | 735| 0|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1128| 0|#line 93 "/src/igraph/src/io/ncol-lexer.l"
1129| 0|{ return ERROR; }
1130| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1131| 0|case 5:
------------------
| Branch (1131:1): [True: 0, False: 1.58M]
------------------
1132| 0|YY_RULE_SETUP
------------------
| | 989| 0| YY_USER_ACTION
| | ------------------
| | | | 735| 0|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 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]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1133| 0|#line 95 "/src/igraph/src/io/ncol-lexer.l"
1134| 0|YY_FATAL_ERROR( "flex scanner jammed" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1135| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1136| 0|#line 1137 "/src/igraph/build/src/io/parsers/ncol-lexer.c"
1137| 3.24k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.24k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.24k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
| Branch (1137:1): [True: 3.24k, False: 1.58M]
------------------
1138| 3.24k| yyterminate();
------------------
| | 948| 3.24k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.24k|#define YY_NULL 0
| | ------------------
------------------
1139| |
1140| 17.1k| case YY_END_OF_BUFFER:
------------------
| | 596| 17.1k|#define YY_END_OF_BUFFER 6
------------------
| Branch (1140:2): [True: 17.1k, False: 1.56M]
------------------
1141| 17.1k| {
1142| | /* Amount of text matched not including the EOB char. */
1143| 17.1k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 17.1k|#define yytext_ptr yytext_r
------------------
1144| |
1145| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1146| 17.1k| *yy_cp = yyg->yy_hold_char;
1147| 17.1k| YY_RESTORE_YY_MORE_OFFSET
1148| |
1149| 17.1k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 17.1k|#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| 17.1k|#define YY_BUFFER_NEW 0
------------------
| Branch (1149:8): [True: 3.24k, False: 13.8k]
------------------
1150| 3.24k| {
1151| | /* We're scanning a new file or input source. It's
1152| | * possible that this happened because the user
1153| | * just pointed yyin at a new source and called
1154| | * yylex(). If so, then we have to assure
1155| | * consistency between YY_CURRENT_BUFFER and our
1156| | * globals. Here is the right place to do so, because
1157| | * this is the first action (other than possibly a
1158| | * back-up) that will match for the new input source.
1159| | */
1160| 3.24k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1161| 3.24k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.24k|#define yyin yyg->yyin_r
------------------
1162| 3.24k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.24k|#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.24k|#define YY_BUFFER_NORMAL 1
------------------
1163| 3.24k| }
1164| |
1165| | /* Note that here we test for yy_c_buf_p "<=" to the position
1166| | * of the first EOB in the buffer, since yy_c_buf_p will
1167| | * already have been incremented past the NUL character
1168| | * (since all states make transitions on EOB to the
1169| | * end-of-buffer state). Contrast this with the test
1170| | * in input().
1171| | */
1172| 17.1k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 17.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1172:8): [True: 0, False: 17.1k]
------------------
1173| 0| { /* This was really a NUL. */
1174| 0| yy_state_type yy_next_state;
1175| |
1176| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
1177| |
1178| 0| yy_current_state = yy_get_previous_state( yyscanner );
1179| |
1180| | /* Okay, we're now positioned to make the NUL
1181| | * transition. We couldn't have
1182| | * yy_get_previous_state() go ahead and do it
1183| | * for us because it doesn't know how to deal
1184| | * with the possibility of jamming (and we don't
1185| | * want to build jamming into it because then it
1186| | * will run more slowly).
1187| | */
1188| |
1189| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1190| |
1191| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 0|#define YY_MORE_ADJ 0
------------------
1192| |
1193| 0| if ( yy_next_state )
------------------
| Branch (1193:9): [True: 0, False: 0]
------------------
1194| 0| {
1195| | /* Consume the NUL. */
1196| 0| yy_cp = ++yyg->yy_c_buf_p;
1197| 0| yy_current_state = yy_next_state;
1198| 0| goto yy_match;
1199| 0| }
1200| |
1201| 0| else
1202| 0| {
1203| 0| yy_cp = yyg->yy_c_buf_p;
1204| 0| goto yy_find_action;
1205| 0| }
1206| 0| }
1207| |
1208| 17.1k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1208:17): [True: 17.1k, False: 0]
------------------
1209| 17.1k| {
1210| 3.24k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.24k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1210:4): [True: 3.24k, False: 13.8k]
------------------
1211| 3.24k| {
1212| 3.24k| yyg->yy_did_buffer_switch_on_eof = 0;
1213| |
1214| 3.24k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.24k|#define yywrap igraph_ncol_yywrap
| | ------------------
| | | | 573| 3.24k|#define igraph_ncol_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:39): [True: 3.24k, Folded]
| | | | ------------------
| | ------------------
------------------
1215| 3.24k| {
1216| | /* Note: because we've taken care in
1217| | * yy_get_next_buffer() to have set up
1218| | * yytext, we can now set up
1219| | * yy_c_buf_p so that if some total
1220| | * hoser (like flex itself) wants to
1221| | * call the scanner after we return the
1222| | * YY_NULL, it'll still work - another
1223| | * YY_NULL will get returned.
1224| | */
1225| 3.24k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.24k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 3.24k|#define YY_MORE_ADJ 0
------------------
1226| |
1227| 3.24k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.24k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.24k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
1228| 3.24k| goto do_action;
1229| 3.24k| }
1230| |
1231| 0| else
1232| 0| {
1233| 0| if ( ! yyg->yy_did_buffer_switch_on_eof )
------------------
| Branch (1233:11): [True: 0, False: 0]
------------------
1234| 0| YY_NEW_FILE;
------------------
| | 379| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner )
| | ------------------
| | | | 98| 0|#define yyrestart igraph_ncol_yyrestart
| | ------------------
| | #define YY_NEW_FILE yyrestart( yyin , yyscanner )
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
------------------
1235| 0| }
1236| 0| break;
1237| 3.24k| }
1238| |
1239| 11.5k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 11.5k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1239:4): [True: 11.5k, False: 5.60k]
------------------
1240| 11.5k| yyg->yy_c_buf_p =
1241| 11.5k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 11.5k|#define yytext_ptr yytext_r
------------------
1242| |
1243| 11.5k| yy_current_state = yy_get_previous_state( yyscanner );
1244| |
1245| 11.5k| yy_cp = yyg->yy_c_buf_p;
1246| 11.5k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 11.5k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 11.5k|#define YY_MORE_ADJ 0
------------------
1247| 11.5k| goto yy_match;
1248| |
1249| 2.36k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 2.36k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1249:4): [True: 2.36k, False: 14.7k]
------------------
1250| 2.36k| yyg->yy_c_buf_p =
1251| 2.36k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 2.36k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1252| |
1253| 2.36k| yy_current_state = yy_get_previous_state( yyscanner );
1254| |
1255| 2.36k| yy_cp = yyg->yy_c_buf_p;
1256| 2.36k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 2.36k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 2.36k|#define YY_MORE_ADJ 0
------------------
1257| 2.36k| goto yy_find_action;
1258| 17.1k| }
1259| 0| break;
1260| 17.1k| }
1261| |
1262| 0| default:
------------------
| Branch (1262:2): [True: 0, False: 1.58M]
------------------
1263| 0| YY_FATAL_ERROR(
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1264| 1.58M| "fatal flex scanner internal error--no action found" );
1265| 1.58M| } /* end of action switch */
1266| 1.58M| } /* end of scanning one token */
1267| 1.12M| } /* end of user's declarations */
1268| 1.12M|} /* end of yylex */
igraph_ncol_yyrestart:
1566| 3.24k|{
1567| 3.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1568| |
1569| 3.24k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.24k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.24k, False: 0]
| | ------------------
| | 522| 3.24k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.24k| : NULL)
------------------
| Branch (1569:7): [True: 0, False: 3.24k]
------------------
1570| 0| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 0|#define yyensure_buffer_stack igraph_ncol_yyensure_buffer_stack
------------------
1571| 0| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1572| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 0|#define yy_create_buffer igraph_ncol_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
------------------
1573| 0| }
1574| |
1575| 3.24k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.24k|#define yy_init_buffer igraph_ncol_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.24k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.24k, False: 0]
| | ------------------
| | 522| 3.24k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.24k| : NULL)
------------------
1576| 3.24k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.24k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1577| 3.24k|}
igraph_ncol_yy_create_buffer:
1631| 3.24k|{
1632| 3.24k| YY_BUFFER_STATE b;
1633| |
1634| 3.24k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.24k|#define yyalloc igraph_ncol_yyalloc
------------------
1635| 3.24k| if ( ! b )
------------------
| Branch (1635:7): [True: 0, False: 3.24k]
------------------
1636| 3.24k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1637| |
1638| 3.24k| b->yy_buf_size = size;
1639| |
1640| | /* yy_ch_buf has to be 2 characters longer than the size given because
1641| | * we need to put in 2 end-of-buffer characters.
1642| | */
1643| 3.24k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.24k|#define yyalloc igraph_ncol_yyalloc
------------------
1644| 3.24k| if ( ! b->yy_ch_buf )
------------------
| Branch (1644:7): [True: 0, False: 3.24k]
------------------
1645| 3.24k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1646| |
1647| 3.24k| b->yy_is_our_buffer = 1;
1648| |
1649| 3.24k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.24k|#define yy_init_buffer igraph_ncol_yy_init_buffer
------------------
1650| |
1651| 3.24k| return b;
1652| 3.24k|}
igraph_ncol_yy_delete_buffer:
1659| 3.24k|{
1660| 3.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1661| |
1662| 3.24k| if ( ! b )
------------------
| Branch (1662:7): [True: 0, False: 3.24k]
------------------
1663| 0| return;
1664| |
1665| 3.24k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.24k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.24k, False: 0]
| | ------------------
| | 522| 3.24k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.24k| : NULL)
------------------
| Branch (1665:7): [True: 3.24k, False: 0]
------------------
1666| 3.24k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1667| |
1668| 3.24k| if ( b->yy_is_our_buffer )
------------------
| Branch (1668:7): [True: 3.24k, False: 0]
------------------
1669| 3.24k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.24k|#define yyfree igraph_ncol_yyfree
------------------
1670| |
1671| 3.24k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.24k|#define yyfree igraph_ncol_yyfree
------------------
1672| 3.24k|}
igraph_ncol_yy_flush_buffer:
1708| 6.49k|{
1709| 6.49k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1710| 6.49k| if ( ! b )
------------------
| Branch (1710:7): [True: 0, False: 6.49k]
------------------
1711| 0| return;
1712| |
1713| 6.49k| b->yy_n_chars = 0;
1714| |
1715| | /* We always need two end-of-buffer characters. The first causes
1716| | * a transition to the end-of-buffer state. The second causes
1717| | * a jam in that state.
1718| | */
1719| 6.49k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.49k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1720| 6.49k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.49k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1721| |
1722| 6.49k| b->yy_buf_pos = &b->yy_ch_buf[0];
1723| |
1724| 6.49k| b->yy_at_bol = 1;
1725| 6.49k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 6.49k|#define YY_BUFFER_NEW 0
------------------
1726| |
1727| 6.49k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 6.49k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.49k, False: 0]
| | ------------------
| | 522| 6.49k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.49k| : NULL)
------------------
| Branch (1727:7): [True: 3.24k, False: 3.24k]
------------------
1728| 3.24k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.24k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1729| 6.49k|}
igraph_ncol_yypop_buffer_state:
1769| 3.24k|{
1770| 3.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1771| 3.24k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.24k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.24k, False: 0]
| | ------------------
| | 522| 3.24k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.24k| : NULL)
------------------
| Branch (1771:6): [True: 3.24k, False: 0]
------------------
1772| 3.24k| return;
1773| |
1774| 0| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
------------------
| | 26| 0|#define yy_delete_buffer igraph_ncol_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)
------------------
1775| 0| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1776| 0| if (yyg->yy_buffer_stack_top > 0)
------------------
| Branch (1776:6): [True: 0, False: 0]
------------------
1777| 0| --yyg->yy_buffer_stack_top;
1778| |
1779| 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)
------------------
1780| 0| yy_load_buffer_state( yyscanner );
------------------
| | 62| 0|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1781| 0| yyg->yy_did_buffer_switch_on_eof = 1;
1782| 0| }
1783| 0|}
igraph_ncol_yyget_leng:
2006| 781k|{
2007| 781k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2008| 781k| return yyleng;
------------------
| | 359| 781k|#define yyleng yyg->yyleng_r
------------------
2009| 781k|}
igraph_ncol_yyget_text:
2016| 781k|{
2017| 781k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2018| 781k| return yytext;
------------------
| | 360| 781k|#define yytext yyg->yytext_r
------------------
2019| 781k|}
igraph_ncol_yyset_extra:
2026| 6.49k|{
2027| 6.49k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2028| 6.49k| yyextra = user_defined ;
------------------
| | 358| 6.49k|#define yyextra yyg->yyextra_r
------------------
2029| 6.49k|}
igraph_ncol_yyset_in:
2068| 3.24k|{
2069| 3.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2070| 3.24k| yyin = _in_str ;
------------------
| | 356| 3.24k|#define yyin yyg->yyin_r
------------------
2071| 3.24k|}
igraph_ncol_yylex_init_extra:
2151| 3.24k|{
2152| 3.24k| struct yyguts_t dummy_yyguts;
2153| |
2154| 3.24k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.24k|#define yyset_extra igraph_ncol_yyset_extra
------------------
2155| |
2156| 3.24k| if (ptr_yy_globals == NULL){
------------------
| Branch (2156:9): [True: 0, False: 3.24k]
------------------
2157| 0| errno = EINVAL;
2158| 0| return 1;
2159| 0| }
2160| |
2161| 3.24k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.24k|#define yyalloc igraph_ncol_yyalloc
------------------
2162| |
2163| 3.24k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2163:9): [True: 0, False: 3.24k]
------------------
2164| 0| errno = ENOMEM;
2165| 0| return 1;
2166| 0| }
2167| |
2168| | /* By setting to 0xAA, we expose bugs in
2169| | yy_init_globals. Leave at 0x00 for releases. */
2170| 3.24k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2171| |
2172| 3.24k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.24k|#define yyset_extra igraph_ncol_yyset_extra
------------------
2173| |
2174| 3.24k| return yy_init_globals ( *ptr_yy_globals );
2175| 3.24k|}
igraph_ncol_yylex_destroy:
2212| 3.24k|{
2213| 3.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2214| |
2215| | /* Pop the buffer stack, destroying each element. */
2216| 6.49k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 6.49k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.24k, False: 3.24k]
| | | Branch (521:29): [True: 6.49k, False: 0]
| | ------------------
| | 522| 6.49k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.49k| : NULL)
------------------
2217| 3.24k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.24k|#define yy_delete_buffer igraph_ncol_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.24k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.24k, False: 0]
| | ------------------
| | 522| 3.24k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.24k| : NULL)
------------------
2218| 3.24k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2219| 3.24k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.24k|#define yypop_buffer_state igraph_ncol_yypop_buffer_state
------------------
2220| 3.24k| }
2221| |
2222| | /* Destroy the stack itself. */
2223| 3.24k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.24k|#define yyfree igraph_ncol_yyfree
------------------
2224| 3.24k| yyg->yy_buffer_stack = NULL;
2225| |
2226| | /* Destroy the start condition stack. */
2227| 3.24k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.24k|#define yyfree igraph_ncol_yyfree
------------------
2228| 3.24k| yyg->yy_start_stack = NULL;
2229| |
2230| | /* Reset the globals. This is important in a non-reentrant scanner so the next time
2231| | * yylex() is called, initialization will occur. */
2232| 3.24k| yy_init_globals( yyscanner);
2233| |
2234| | /* Destroy the main struct (reentrant only). */
2235| 3.24k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.24k|#define yyfree igraph_ncol_yyfree
------------------
2236| | yyscanner = NULL;
2237| 3.24k| return 0;
2238| 3.24k|}
igraph_ncol_yyalloc:
2268| 12.9k|{
2269| 12.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2270| 12.9k| (void)yyg;
2271| 12.9k| return malloc(size);
2272| 12.9k|}
igraph_ncol_yyrealloc:
2275| 89|{
2276| 89| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2277| 89| (void)yyg;
2278| |
2279| | /* The cast to (char *) in the following accommodates both
2280| | * implementations that use char* generic pointers, and those
2281| | * that use void* generic pointers. It works with the latter
2282| | * because both ANSI C and C++ allow castless assignment from
2283| | * any pointer type to void*, and deal with argument conversions
2284| | * as though doing an assignment.
2285| | */
2286| 89| return realloc(ptr, size);
2287| 89|}
igraph_ncol_yyfree:
2290| 16.2k|{
2291| 16.2k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2292| 16.2k| (void)yyg;
2293| 16.2k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2294| 16.2k|}
ncol-lexer.c:yy_get_next_buffer:
1278| 17.1k|{
1279| 17.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1280| 17.1k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 17.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1281| 17.1k| char *source = yyg->yytext_ptr;
------------------
| | 579| 17.1k|#define yytext_ptr yytext_r
------------------
1282| 17.1k| int number_to_move, i;
1283| 17.1k| int ret_val;
1284| |
1285| 17.1k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 17.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1285:7): [True: 0, False: 17.1k]
------------------
1286| 17.1k| YY_FATAL_ERROR(
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1287| 17.1k| "fatal flex scanner internal error--end of buffer missed" );
1288| |
1289| 17.1k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 17.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1289:7): [True: 0, False: 17.1k]
------------------
1290| 0| { /* Don't try to fill the buffer, so this is an EOF. */
1291| 0| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
------------------
| | 579| 0|#define yytext_ptr yytext_r
------------------
if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
------------------
| | 681| 0|#define YY_MORE_ADJ 0
------------------
| Branch (1291:8): [True: 0, False: 0]
------------------
1292| 0| {
1293| | /* We matched a single character, the EOB, so
1294| | * treat this as a final EOF.
1295| | */
1296| 0| return EOB_ACT_END_OF_FILE;
------------------
| | 410| 0|#define EOB_ACT_END_OF_FILE 1
------------------
1297| 0| }
1298| |
1299| 0| else
1300| 0| {
1301| | /* We matched some text prior to the EOB, first
1302| | * process it.
1303| | */
1304| 0| return EOB_ACT_LAST_MATCH;
------------------
| | 411| 0|#define EOB_ACT_LAST_MATCH 2
------------------
1305| 0| }
1306| 0| }
1307| |
1308| | /* Try to read more data. */
1309| |
1310| | /* First move last chars to start of buffer. */
1311| 17.1k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 17.1k|#define yytext_ptr yytext_r
------------------
1312| |
1313| 248M| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1313:15): [True: 248M, False: 17.1k]
------------------
1314| 248M| *(dest++) = *(source++);
1315| |
1316| 17.1k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 17.1k|#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| 17.1k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1316:7): [True: 2.36k, False: 14.7k]
------------------
1317| | /* don't do the read, it's not guaranteed to return an EOF,
1318| | * just force an EOF
1319| | */
1320| 2.36k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 2.36k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1321| |
1322| 14.7k| else
1323| 14.7k| {
1324| 14.7k| int num_to_read =
1325| 14.7k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 14.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1326| |
1327| 14.8k| while ( num_to_read <= 0 )
------------------
| Branch (1327:11): [True: 89, False: 14.7k]
------------------
1328| 89| { /* Not enough room in the buffer - grow it. */
1329| |
1330| | /* just a shorter name for the current buffer */
1331| 89| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 89|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1332| |
1333| 89| int yy_c_buf_p_offset =
1334| 89| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1335| |
1336| 89| if ( b->yy_is_our_buffer )
------------------
| Branch (1336:9): [True: 89, False: 0]
------------------
1337| 89| {
1338| 89| int new_size = b->yy_buf_size * 2;
1339| |
1340| 89| if ( new_size <= 0 )
------------------
| Branch (1340:10): [True: 0, False: 89]
------------------
1341| 0| b->yy_buf_size += b->yy_buf_size / 8;
1342| 89| else
1343| 89| b->yy_buf_size *= 2;
1344| |
1345| 89| b->yy_ch_buf = (char *)
1346| | /* Include room in for 2 EOB chars. */
1347| 89| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 89|#define yyrealloc igraph_ncol_yyrealloc
------------------
1348| 89| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1349| 89| }
1350| 0| else
1351| | /* Can't grow it, we don't own it. */
1352| 0| b->yy_ch_buf = NULL;
1353| |
1354| 89| if ( ! b->yy_ch_buf )
------------------
| Branch (1354:9): [True: 0, False: 89]
------------------
1355| 89| YY_FATAL_ERROR(
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1356| 89| "fatal error - scanner input buffer overflow" );
1357| |
1358| 89| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1359| |
1360| 89| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 89|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1361| 89| number_to_move - 1;
1362| |
1363| 89| }
1364| |
1365| 14.7k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 895| 14.7k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1365:8): [True: 13.6k, False: 1.11k]
------------------
1366| 13.6k| num_to_read = YY_READ_BUF_SIZE;
------------------
| | 895| 13.6k|#define YY_READ_BUF_SIZE 8192
------------------
1367| |
1368| | /* Read in more data. */
1369| 14.7k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 912| 14.7k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 14.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (912:7): [True: 0, False: 14.7k]
| | ------------------
| | 913| 14.7k| { \
| | 914| 0| int c = '*'; \
| | 915| 0| int n; \
| | 916| 0| for ( n = 0; n < max_size && \
| | ------------------
| | | Branch (916:16): [True: 0, False: 0]
| | ------------------
| | 917| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (917:9): [True: 0, False: 0]
| | | Branch (917:38): [True: 0, False: 0]
| | ------------------
| | 918| 0| buf[n] = (char) c; \
| | 919| 0| if ( c == '\n' ) \
| | ------------------
| | | Branch (919:8): [True: 0, False: 0]
| | ------------------
| | 920| 0| buf[n++] = (char) c; \
| | 921| 0| if ( c == EOF && ferror( yyin ) ) \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (921:8): [True: 0, False: 0]
| | | Branch (921:20): [True: 0, False: 0]
| | ------------------
| | 922| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \
| | ------------------
| | | | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | | | ------------------
| | | | | | 895| 0| do { \
| | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | | | 897| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (897:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 923| 0| result = n; \
| | 924| 0| } \
| | 925| 14.7k| else \
| | 926| 14.7k| { \
| | 927| 14.7k| errno=0; \
| | 928| 14.7k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 14.7k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.24k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (928:11): [True: 3.24k, False: 11.5k]
| | | Branch (928:78): [True: 0, False: 3.24k]
| | ------------------
| | 929| 14.7k| { \
| | 930| 0| if( errno != EINTR) \
| | ------------------
| | | Branch (930:8): [True: 0, False: 0]
| | ------------------
| | 931| 0| { \
| | 932| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \
| | ------------------
| | | | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | | | ------------------
| | | | | | 895| 0| do { \
| | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | | | 897| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (897:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 933| 0| break; \
| | 934| 0| } \
| | 935| 0| errno=0; \
| | 936| 0| clearerr(yyin); \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | 937| 0| } \
| | 938| 14.7k| }\
------------------
1370| 14.7k| yyg->yy_n_chars, num_to_read );
1371| |
1372| 14.7k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 14.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1373| 14.7k| }
1374| |
1375| 17.1k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1375:7): [True: 5.60k, False: 11.5k]
------------------
1376| 5.60k| {
1377| 5.60k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 681| 5.60k|#define YY_MORE_ADJ 0
------------------
| Branch (1377:8): [True: 3.24k, False: 2.36k]
------------------
1378| 3.24k| {
1379| 3.24k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.24k|#define EOB_ACT_END_OF_FILE 1
------------------
1380| 3.24k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.24k|#define yyrestart igraph_ncol_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.24k|#define yyin yyg->yyin_r
------------------
1381| 3.24k| }
1382| |
1383| 2.36k| else
1384| 2.36k| {
1385| 2.36k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 2.36k|#define EOB_ACT_LAST_MATCH 2
------------------
1386| 2.36k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 2.36k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1387| 2.36k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 2.36k|#define YY_BUFFER_EOF_PENDING 2
------------------
1388| 2.36k| }
1389| 5.60k| }
1390| |
1391| 11.5k| else
1392| 11.5k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 11.5k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1393| |
1394| 17.1k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 17.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1394:6): [True: 0, False: 17.1k]
------------------
1395| | /* Extend the array by 50%, plus the number we really need. */
1396| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1397| 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_ncol_yyrealloc
------------------
1398| 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]
------------------
1399| 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 (1399:8): [True: 0, False: 0]
------------------
1400| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1401| | /* "- 2" to take care of EOB's */
1402| 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]
------------------
1403| 0| }
1404| |
1405| 17.1k| yyg->yy_n_chars += number_to_move;
1406| 17.1k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 17.1k|#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| 17.1k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1407| 17.1k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 17.1k|#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| 17.1k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1408| |
1409| 17.1k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 17.1k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 17.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1410| |
1411| 17.1k| return ret_val;
1412| 17.1k|}
ncol-lexer.c:yy_get_previous_state:
1417| 13.8k|{
1418| 13.8k| yy_state_type yy_current_state;
1419| 13.8k| char *yy_cp;
1420| 13.8k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1421| |
1422| 13.8k| yy_current_state = yyg->yy_start;
1423| |
1424| 248M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 579| 13.8k|#define yytext_ptr yytext_r
------------------
for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 681| 13.8k|#define YY_MORE_ADJ 0
------------------
| Branch (1424:47): [True: 248M, False: 13.8k]
------------------
1425| 248M| {
1426| 248M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
------------------
| | 346| 248M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1426:19): [True: 248M, False: 0]
------------------
1427| 248M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1427:8): [True: 248M, False: 11.5k]
------------------
1428| 248M| {
1429| 248M| yyg->yy_last_accepting_state = yy_current_state;
1430| 248M| yyg->yy_last_accepting_cpos = yy_cp;
1431| 248M| }
1432| 497M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1432:11): [True: 248M, False: 248M]
------------------
1433| 248M| {
1434| 248M| yy_current_state = (int) yy_def[yy_current_state];
1435| 248M| if ( yy_current_state >= 15 )
------------------
| Branch (1435:9): [True: 248M, False: 7.02k]
------------------
1436| 248M| yy_c = yy_meta[yy_c];
1437| 248M| }
1438| 248M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1439| 248M| }
1440| |
1441| 13.8k| return yy_current_state;
1442| 13.8k|}
ncol-lexer.c:igraph_ncol_yy_load_buffer_state:
1616| 9.74k|{
1617| 9.74k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1618| 9.74k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 9.74k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1619| 9.74k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 9.74k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 9.74k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1620| 9.74k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 9.74k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 9.74k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1621| 9.74k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1622| 9.74k|}
ncol-lexer.c:igraph_ncol_yy_init_buffer:
1680| 6.49k|{
1681| 6.49k| int oerrno = errno;
1682| 6.49k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1683| |
1684| 6.49k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 6.49k|#define yy_flush_buffer igraph_ncol_yy_flush_buffer
------------------
1685| |
1686| 6.49k| b->yy_input_file = file;
1687| 6.49k| b->yy_fill_buffer = 1;
1688| |
1689| | /* If b is the current buffer, then yy_init_buffer was _probably_
1690| | * called from yyrestart() or through yy_get_next_buffer.
1691| | * In that case, we don't want to reset the lineno or column.
1692| | */
1693| 6.49k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 6.49k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.49k, False: 0]
| | ------------------
| | 522| 6.49k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.49k| : NULL)
------------------
| Branch (1693:9): [True: 3.24k, False: 3.24k]
------------------
1694| 3.24k| b->yy_bs_lineno = 1;
1695| 3.24k| b->yy_bs_column = 0;
1696| 3.24k| }
1697| |
1698| 6.49k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1698:32): [True: 6.49k, False: 0]
------------------
1699| |
1700| | errno = oerrno;
1701| 6.49k|}
ncol-lexer.c:igraph_ncol_yyensure_buffer_stack:
1789| 3.24k|{
1790| 3.24k| yy_size_t num_to_alloc;
1791| 3.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1792| |
1793| 3.24k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1793:6): [True: 3.24k, False: 0]
------------------
1794| |
1795| | /* First allocation is just for 2 elements, since we don't know if this
1796| | * scanner will even need a stack. We use 2 instead of 1 to avoid an
1797| | * immediate realloc on the next call.
1798| | */
1799| 3.24k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1800| 3.24k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.24k|#define yyalloc igraph_ncol_yyalloc
------------------
1801| 3.24k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1802| 3.24k| , yyscanner);
1803| 3.24k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1803:8): [True: 0, False: 3.24k]
------------------
1804| 3.24k| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1805| |
1806| 3.24k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1807| |
1808| 3.24k| yyg->yy_buffer_stack_max = num_to_alloc;
1809| 3.24k| yyg->yy_buffer_stack_top = 0;
1810| 3.24k| return;
1811| 3.24k| }
1812| |
1813| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
------------------
| Branch (1813:6): [True: 0, False: 0]
------------------
1814| |
1815| | /* Increase the buffer to prepare for a possible push. */
1816| 0| yy_size_t grow_size = 8 /* arbitrary grow size */;
1817| |
1818| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1819| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
------------------
| | 242| 0|#define yyrealloc igraph_ncol_yyrealloc
------------------
1820| 0| (yyg->yy_buffer_stack,
1821| 0| num_to_alloc * sizeof(struct yy_buffer_state*)
1822| 0| , yyscanner);
1823| 0| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1823:8): [True: 0, False: 0]
------------------
1824| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
------------------
| | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | ------------------
| | | | 895| 0| do { \
| | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | 897| 0| } while (0)
| | | | ------------------
| | | | | Branch (897:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
------------------
1825| |
1826| | /* zero only the new slots.*/
1827| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1828| 0| yyg->yy_buffer_stack_max = num_to_alloc;
1829| 0| }
1830| 0|}
ncol-lexer.c:yy_init_globals:
2178| 6.49k|{
2179| 6.49k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2180| | /* Initialization is the same as for the non-reentrant scanner.
2181| | * This function is called from yylex_destroy(), so don't allocate here.
2182| | */
2183| |
2184| 6.49k| yyg->yy_buffer_stack = NULL;
2185| 6.49k| yyg->yy_buffer_stack_top = 0;
2186| 6.49k| yyg->yy_buffer_stack_max = 0;
2187| 6.49k| yyg->yy_c_buf_p = NULL;
2188| 6.49k| yyg->yy_init = 0;
2189| 6.49k| yyg->yy_start = 0;
2190| |
2191| 6.49k| yyg->yy_start_stack_ptr = 0;
2192| 6.49k| yyg->yy_start_stack_depth = 0;
2193| 6.49k| yyg->yy_start_stack = NULL;
2194| |
2195| |/* Defined in main.c */
2196| |#ifdef YY_STDINIT
2197| | yyin = stdin;
2198| | yyout = stdout;
2199| |#else
2200| 6.49k| yyin = NULL;
------------------
| | 356| 6.49k|#define yyin yyg->yyin_r
------------------
2201| 6.49k| yyout = NULL;
------------------
| | 357| 6.49k|#define yyout yyg->yyout_r
------------------
2202| 6.49k|#endif
2203| |
2204| | /* For future reference: Set errno on error, since we are called by
2205| | * yylex_init()
2206| | */
2207| 6.49k| return 0;
2208| 6.49k|}
igraph_ncol_yyparse:
1184| 3.24k|{
1185| |/* The lookahead symbol. */
1186| 3.24k|int yychar;
1187| |
1188| |
1189| |/* The semantic value of the lookahead symbol. */
1190| |/* Default value used for initialization, for pacifying older GCCs
1191| | or non-GCC compilers. */
1192| 3.24k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 358| 3.24k|# define YY_INITIAL_VALUE(Value) Value
------------------
1193| 3.24k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 358| 3.24k|# define YY_INITIAL_VALUE(Value) Value
------------------
1194| |
1195| |/* Location data for the lookahead symbol. */
1196| 3.24k|static YYLTYPE yyloc_default
1197| 3.24k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1198| 3.24k| = { 1, 1, 1, 1 }
1199| 3.24k|# endif
1200| 3.24k|;
1201| 3.24k|YYLTYPE yylloc = yyloc_default;
1202| |
1203| | /* Number of syntax errors so far. */
1204| 3.24k| int yynerrs;
1205| |
1206| 3.24k| yy_state_fast_t yystate;
1207| | /* Number of tokens to shift before error messages enabled. */
1208| 3.24k| int yyerrstatus;
1209| |
1210| | /* The stacks and their tools:
1211| | 'yyss': related to states.
1212| | 'yyvs': related to semantic values.
1213| | 'yyls': related to locations.
1214| |
1215| | Refer to the stacks through separate pointers, to allow yyoverflow
1216| | to reallocate them elsewhere. */
1217| |
1218| | /* The state stack. */
1219| 3.24k| yy_state_t yyssa[YYINITDEPTH];
1220| 3.24k| yy_state_t *yyss;
1221| 3.24k| yy_state_t *yyssp;
1222| |
1223| | /* The semantic value stack. */
1224| 3.24k| YYSTYPE yyvsa[YYINITDEPTH];
1225| 3.24k| YYSTYPE *yyvs;
1226| 3.24k| YYSTYPE *yyvsp;
1227| |
1228| | /* The location stack. */
1229| 3.24k| YYLTYPE yylsa[YYINITDEPTH];
1230| 3.24k| YYLTYPE *yyls;
1231| 3.24k| YYLTYPE *yylsp;
1232| |
1233| | /* The locations where the error started and ended. */
1234| 3.24k| YYLTYPE yyerror_range[3];
1235| |
1236| 3.24k| YYPTRDIFF_T yystacksize;
------------------
| | 273| 3.24k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1237| |
1238| 3.24k| int yyn;
1239| 3.24k| int yyresult;
1240| | /* Lookahead token as an internal (translated) token number. */
1241| 3.24k| int yytoken = 0;
1242| | /* The variables used to return semantic value and location from the
1243| | action routines. */
1244| 3.24k| YYSTYPE yyval;
1245| 3.24k| YYLTYPE yyloc;
1246| |
1247| 3.24k|#if YYERROR_VERBOSE
1248| | /* Buffer for error messages, and its allocated size. */
1249| 3.24k| char yymsgbuf[128];
1250| 3.24k| char *yymsg = yymsgbuf;
1251| 3.24k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 273| 3.24k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1252| 3.24k|#endif
1253| |
1254| 3.24k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1255| |
1256| | /* The number of symbols on the RHS of the reduced rule.
1257| | Keep to zero when no symbol should be popped. */
1258| 3.24k| int yylen = 0;
1259| |
1260| 3.24k| yyssp = yyss = yyssa;
1261| 3.24k| yyvsp = yyvs = yyvsa;
1262| 3.24k| yylsp = yyls = yylsa;
1263| 3.24k| yystacksize = YYINITDEPTH;
------------------
| | 909| 3.24k|# define YYINITDEPTH 200
------------------
1264| |
1265| 3.24k| YYDPRINTF ((stderr, "Starting parse\n"));
1266| |
1267| 3.24k| yystate = 0;
1268| 3.24k| yyerrstatus = 0;
1269| 3.24k| yynerrs = 0;
------------------
| | 71| 3.24k|#define yynerrs igraph_ncol_yynerrs
------------------
1270| 3.24k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 673| 3.24k|#define YYEMPTY (-2)
------------------
1271| 3.24k| yylsp[0] = yylloc;
1272| 3.24k| goto yysetstate;
1273| |
1274| |
1275| |/*------------------------------------------------------------.
1276| || yynewstate -- push a new state, which is found in yystate. |
1277| |`------------------------------------------------------------*/
1278| 2.94M|yynewstate:
1279| | /* In all cases, when you get here, the value and location stacks
1280| | have just been pushed. So pushing a state here evens the stacks. */
1281| 2.94M| yyssp++;
1282| |
1283| |
1284| |/*--------------------------------------------------------------------.
1285| || yysetstate -- set current state (the top of the stack) to yystate. |
1286| |`--------------------------------------------------------------------*/
1287| 2.94M|yysetstate:
1288| 2.94M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1289| 2.94M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 381| 2.94M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (381:31): [Folded, False: 2.94M]
| | | Branch (381:37): [True: 0, False: 0]
| | | Branch (381:37): [True: 0, False: 0]
| | ------------------
------------------
1290| 2.94M| YY_IGNORE_USELESS_CAST_BEGIN
1291| 2.94M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 125| 2.94M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1292| 2.94M| YY_IGNORE_USELESS_CAST_END
1293| |
1294| 2.94M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1294:7): [True: 0, False: 2.94M]
------------------
1295| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1296| | goto yyexhaustedlab;
1297| |#else
1298| 0| {
1299| | /* Get the current used size of the three stacks, in elements. */
1300| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1;
------------------
| | 273| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1301| |
1302| |# if defined yyoverflow
1303| | {
1304| | /* Give user a chance to reallocate the stack. Use copies of
1305| | these so that the &'s don't force the real ones into
1306| | memory. */
1307| | yy_state_t *yyss1 = yyss;
1308| | YYSTYPE *yyvs1 = yyvs;
1309| | YYLTYPE *yyls1 = yyls;
1310| |
1311| | /* Each stack pointer address is followed by the size of the
1312| | data in use in that stack, in bytes. This used to be a
1313| | conditional around just the two extra args, but that might
1314| | be undefined if yyoverflow is a macro. */
1315| | yyoverflow (YY_("memory exhausted"),
1316| | &yyss1, yysize * YYSIZEOF (*yyssp),
1317| | &yyvs1, yysize * YYSIZEOF (*yyvsp),
1318| | &yyls1, yysize * YYSIZEOF (*yylsp),
1319| | &yystacksize);
1320| | yyss = yyss1;
1321| | yyvs = yyvs1;
1322| | yyls = yyls1;
1323| | }
1324| |# else /* defined YYSTACK_RELOCATE */
1325| | /* Extend the stack our own way. */
1326| 0| if (YYMAXDEPTH <= yystacksize)
------------------
| | 920| 0|# define YYMAXDEPTH 10000
------------------
| Branch (1326:11): [True: 0, False: 0]
------------------
1327| 0| goto yyexhaustedlab;
1328| 0| yystacksize *= 2;
1329| 0| if (YYMAXDEPTH < yystacksize)
------------------
| | 920| 0|# define YYMAXDEPTH 10000
------------------
| Branch (1329:11): [True: 0, False: 0]
------------------
1330| 0| yystacksize = YYMAXDEPTH;
------------------
| | 920| 0|# define YYMAXDEPTH 10000
------------------
1331| |
1332| 0| {
1333| 0| yy_state_t *yyss1 = yyss;
1334| 0| union yyalloc *yyptr =
1335| 0| YY_CAST (union yyalloc *,
------------------
| | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1336| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1337| 0| if (! yyptr)
------------------
| Branch (1337:13): [True: 0, False: 0]
------------------
1338| 0| goto yyexhaustedlab;
1339| 0| YYSTACK_RELOCATE (yyss_alloc, yyss);
------------------
| | 482| 0| do \
| | 483| 0| { \
| | 484| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 273| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 485| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 500| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 486| 0| Stack = &yyptr->Stack_alloc; \
| | 487| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 465| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 488| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 489| 0| } \
| | 490| 0| while (0)
| | ------------------
| | | Branch (490:12): [Folded, False: 0]
| | ------------------
------------------
1340| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs);
------------------
| | 482| 0| do \
| | 483| 0| { \
| | 484| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 273| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 485| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 500| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 486| 0| Stack = &yyptr->Stack_alloc; \
| | 487| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 465| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 488| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 489| 0| } \
| | 490| 0| while (0)
| | ------------------
| | | Branch (490:12): [Folded, False: 0]
| | ------------------
------------------
1341| 0| YYSTACK_RELOCATE (yyls_alloc, yyls);
------------------
| | 482| 0| do \
| | 483| 0| { \
| | 484| 0| YYPTRDIFF_T yynewbytes; \
| | ------------------
| | | | 273| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__
| | ------------------
| | 485| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
| | ------------------
| | | | 500| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 486| 0| Stack = &yyptr->Stack_alloc; \
| | 487| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
| | ------------------
| | | | 465| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
| | | | ------------------
| | | | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | | | ------------------
| | | | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 488| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \
| | ------------------
| | | | 306| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
| | | | ------------------
| | | | | | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
| | | | ------------------
| | ------------------
| | 489| 0| } \
| | 490| 0| while (0)
| | ------------------
| | | Branch (490:12): [Folded, False: 0]
| | ------------------
------------------
1342| 0|# undef YYSTACK_RELOCATE
1343| 0| if (yyss1 != yyssa)
------------------
| Branch (1343:13): [True: 0, False: 0]
------------------
1344| 0| YYSTACK_FREE (yyss1);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1345| 0| }
1346| 0|# endif
1347| |
1348| 0| yyssp = yyss + yysize - 1;
1349| 0| yyvsp = yyvs + yysize - 1;
1350| 0| yylsp = yyls + yysize - 1;
1351| |
1352| 0| YY_IGNORE_USELESS_CAST_BEGIN
1353| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1354| 0| YY_CAST (long, yystacksize)));
1355| 0| YY_IGNORE_USELESS_CAST_END
1356| |
1357| 0| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1357:11): [True: 0, False: 0]
------------------
1358| 0| YYABORT;
------------------
| | 677| 0|#define YYABORT goto yyabortlab
------------------
1359| 0| }
1360| 2.94M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1361| |
1362| 2.94M| if (yystate == YYFINAL)
------------------
| | 515| 2.94M|#define YYFINAL 2
------------------
| Branch (1362:7): [True: 3.24k, False: 2.94M]
------------------
1363| 3.24k| YYACCEPT;
------------------
| | 676| 3.24k|#define YYACCEPT goto yyacceptlab
------------------
1364| |
1365| 2.94M| goto yybackup;
1366| |
1367| |
1368| |/*-----------.
1369| || yybackup. |
1370| |`-----------*/
1371| 2.94M|yybackup:
1372| | /* Do appropriate processing given the current state. Read a
1373| | lookahead token if we need one and don't already have one. */
1374| |
1375| | /* First try to decide what to do without reference to lookahead token. */
1376| 2.94M| yyn = yypact[yystate];
1377| 2.94M| if (yypact_value_is_default (yyn))
------------------
| | 601| 2.94M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 598| 2.94M|#define YYPACT_NINF (-3)
| | ------------------
| | | Branch (601:3): [True: 1.81M, False: 1.12M]
| | ------------------
------------------
1378| 1.81M| goto yydefault;
1379| |
1380| | /* Not known => get a lookahead token if don't already have one. */
1381| |
1382| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1383| 1.12M| if (yychar == YYEMPTY)
------------------
| | 673| 1.12M|#define YYEMPTY (-2)
------------------
| Branch (1383:7): [True: 1.12M, False: 0]
------------------
1384| 1.12M| {
1385| 1.12M| YYDPRINTF ((stderr, "Reading a token: "));
1386| 1.12M| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 1.12M|#define yylex igraph_ncol_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 116| 1.12M|#define scanner context->scanner
------------------
1387| 1.12M| }
1388| |
1389| 1.12M| if (yychar <= YYEOF)
------------------
| | 674| 1.12M|#define YYEOF 0
------------------
| Branch (1389:7): [True: 3.24k, False: 1.12M]
------------------
1390| 3.24k| {
1391| 3.24k| yychar = yytoken = YYEOF;
------------------
| | 674| 3.24k|#define YYEOF 0
------------------
1392| 3.24k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1393| 3.24k| }
1394| 1.12M| else
1395| 1.12M| {
1396| 1.12M| yytoken = YYTRANSLATE (yychar);
------------------
| | 535| 1.12M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 1.12M|#define YYMAXUTOK 260
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 1.12M, False: 0]
| | | Branch (535:18): [True: 1.12M, False: 0]
| | ------------------
------------------
1397| 1.12M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1398| 1.12M| }
1399| |
1400| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1401| | detect an error, take that action. */
1402| 1.12M| yyn += yytoken;
1403| 1.12M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 517| 1.12M|#define YYLAST 7
------------------
| Branch (1403:7): [True: 0, False: 1.12M]
| Branch (1403:18): [True: 0, False: 1.12M]
| Branch (1403:34): [True: 0, False: 1.12M]
------------------
1404| 0| goto yydefault;
1405| 1.12M| yyn = yytable[yyn];
1406| 1.12M| if (yyn <= 0)
------------------
| Branch (1406:7): [True: 0, False: 1.12M]
------------------
1407| 0| {
1408| 0| if (yytable_value_is_error (yyn))
------------------
| | 606| 0| 0
| | ------------------
| | | Branch (606:3): [Folded, False: 0]
| | ------------------
------------------
1409| 0| goto yyerrlab;
1410| 0| yyn = -yyn;
1411| 0| goto yyreduce;
1412| 0| }
1413| |
1414| | /* Count tokens shifted since error; after three, turn off error
1415| | status. */
1416| 1.12M| if (yyerrstatus)
------------------
| Branch (1416:7): [True: 0, False: 1.12M]
------------------
1417| 0| yyerrstatus--;
1418| |
1419| | /* Shift the lookahead token. */
1420| 1.12M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1421| 1.12M| yystate = yyn;
1422| 1.12M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1423| 1.12M| *++yyvsp = yylval;
1424| 1.12M| YY_IGNORE_MAYBE_UNINITIALIZED_END
1425| 1.12M| *++yylsp = yylloc;
1426| |
1427| | /* Discard the shifted token. */
1428| 1.12M| yychar = YYEMPTY;
------------------
| | 673| 1.12M|#define YYEMPTY (-2)
------------------
1429| 1.12M| goto yynewstate;
1430| |
1431| |
1432| |/*-----------------------------------------------------------.
1433| || yydefault -- do the default action for the current state. |
1434| |`-----------------------------------------------------------*/
1435| 1.81M|yydefault:
1436| 1.81M| yyn = yydefact[yystate];
1437| 1.81M| if (yyn == 0)
------------------
| Branch (1437:7): [True: 0, False: 1.81M]
------------------
1438| 0| goto yyerrlab;
1439| 1.81M| goto yyreduce;
1440| |
1441| |
1442| |/*-----------------------------.
1443| || yyreduce -- do a reduction. |
1444| |`-----------------------------*/
1445| 1.81M|yyreduce:
1446| | /* yyn is the number of a rule to reduce with. */
1447| 1.81M| yylen = yyr2[yyn];
1448| |
1449| | /* If YYLEN is nonzero, implement the default value of the action:
1450| | '$$ = $1'.
1451| |
1452| | Otherwise, the following line sets YYVAL to garbage.
1453| | This behavior is undocumented and Bison
1454| | users should not rely upon it. Assigning to YYVAL
1455| | unconditionally makes the parser a bit smaller, and it avoids a
1456| | GCC warning that YYVAL may be used uninitialized. */
1457| 1.81M| yyval = yyvsp[1-yylen];
1458| |
1459| | /* Default location. */
1460| 1.81M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 711| 1.81M| do \
| | 712| 1.81M| if (N) \
| | ------------------
| | | Branch (712:11): [True: 1.81M, False: 3.24k]
| | ------------------
| | 713| 1.81M| { \
| | 714| 1.81M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 729| 1.81M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 715| 1.81M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 729| 1.81M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 716| 1.81M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 729| 1.81M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 717| 1.81M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 729| 1.81M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 718| 1.81M| } \
| | 719| 1.81M| else \
| | 720| 1.81M| { \
| | 721| 3.24k| (Current).first_line = (Current).last_line = \
| | 722| 3.24k| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 729| 3.24k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 723| 3.24k| (Current).first_column = (Current).last_column = \
| | 724| 3.24k| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 729| 3.24k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 725| 3.24k| } \
| | 726| 1.81M| while (0)
| | ------------------
| | | Branch (726:12): [Folded, False: 1.81M]
| | ------------------
------------------
1461| 1.81M| yyerror_range[1] = yyloc;
1462| 1.81M| YY_REDUCE_PRINT (yyn);
1463| 1.81M| switch (yyn)
1464| 1.81M| {
1465| 248k| case 5:
------------------
| Branch (1465:3): [True: 248k, False: 1.56M]
------------------
1466| 248k|#line 97 "/src/igraph/src/io/ncol-parser.y"
1467| 248k| {
1468| 248k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, 1.0));
------------------
| | 10| 248k| do { \
| | 11| 248k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 248k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 248k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 248k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_ncol_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 677| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 248k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 248k]
| | ------------------
------------------
1469| 248k| }
1470| 248k|#line 1471 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1471| 248k| break;
1472| |
1473| 248k| case 6:
------------------
| Branch (1473:3): [True: 94.7k, False: 1.72M]
------------------
1474| 94.7k|#line 100 "/src/igraph/src/io/ncol-parser.y"
1475| 94.7k| {
1476| 94.7k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, (yyvsp[-1].weightnum)));
------------------
| | 10| 94.7k| do { \
| | 11| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_ncol_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 677| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 94.7k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 94.7k]
| | ------------------
------------------
1477| 94.7k| context->has_weights = true;
1478| 94.7k| }
1479| 0|#line 1480 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1480| 0| break;
1481| |
1482| 343k| case 7:
------------------
| Branch (1482:3): [True: 343k, False: 1.47M]
------------------
1483| 343k|#line 106 "/src/igraph/src/io/ncol-parser.y"
1484| 343k| {
1485| 343k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-1].edgenum)));
------------------
| | 10| 343k| do { \
| | 11| 343k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 343k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 343k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 343k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_ncol_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 677| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 343k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 343k]
| | ------------------
------------------
1486| 343k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[0].edgenum)));
------------------
| | 10| 343k| do { \
| | 11| 343k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 343k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 343k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 343k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_ncol_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 677| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 343k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 343k]
| | ------------------
------------------
1487| 343k|}
1488| 343k|#line 1489 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1489| 343k| break;
1490| |
1491| 687k| case 8:
------------------
| Branch (1491:3): [True: 687k, False: 1.12M]
------------------
1492| 687k|#line 111 "/src/igraph/src/io/ncol-parser.y"
1493| 687k| {
1494| 687k| igraph_int_t trie_id;
1495| 687k| IGRAPH_YY_CHECK(igraph_trie_get_len(context->trie,
------------------
| | 10| 687k| do { \
| | 11| 687k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 687k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 687k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 687k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_ncol_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 677| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 687k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 687k]
| | ------------------
------------------
1496| 687k| igraph_ncol_yyget_text(scanner),
1497| 687k| igraph_ncol_yyget_leng(scanner),
1498| 687k| &trie_id
1499| 687k| ));
1500| 687k| (yyval.edgenum) = trie_id;
1501| 687k|}
1502| 0|#line 1503 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1503| 0| break;
1504| |
1505| 94.7k| case 9:
------------------
| Branch (1505:3): [True: 94.7k, False: 1.72M]
------------------
1506| 94.7k|#line 121 "/src/igraph/src/io/ncol-parser.y"
1507| 94.7k| {
1508| 94.7k| igraph_real_t val;
1509| 94.7k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_ncol_yyget_text(scanner),
------------------
| | 10| 94.7k| do { \
| | 11| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 13| 0| context->igraph_errno = igraph_i_ret; \
| | 14| 0| yyerror(&yylloc, context, "failed"); \
| | ------------------
| | | | 69| 0|#define yyerror igraph_ncol_yyerror
| | ------------------
| | 15| 0| YYABORT; \
| | ------------------
| | | | 677| 0|#define YYABORT goto yyabortlab
| | ------------------
| | 16| 0| } \
| | 17| 94.7k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 94.7k]
| | ------------------
------------------
1510| 94.7k| igraph_ncol_yyget_leng(scanner),
1511| 94.7k| &val));
1512| 94.7k| (yyval.weightnum)=val;
1513| 94.7k|}
1514| 0|#line 1515 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1515| 0| break;
1516| |
1517| |
1518| 0|#line 1519 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1519| |
1520| 346k| default: break;
------------------
| Branch (1520:7): [True: 346k, False: 1.46M]
------------------
1521| 1.81M| }
1522| | /* User semantic actions sometimes alter yychar, and that requires
1523| | that yytoken be updated with the new translation. We take the
1524| | approach of translating immediately before every use of yytoken.
1525| | One alternative is translating here after every semantic action,
1526| | but that translation would be missed if the semantic action invokes
1527| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1528| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1529| | incorrect destructor might then be invoked immediately. In the
1530| | case of YYERROR or YYBACKUP, subsequent parser actions might lead
1531| | to an incorrect destructor call or verbose syntax error message
1532| | before the lookahead is translated. */
1533| 1.81M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1534| |
1535| 1.81M| YYPOPSTACK (yylen);
------------------
| | 1254| 1.81M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1536| 1.81M| yylen = 0;
1537| 1.81M| YY_STACK_PRINT (yyss, yyssp);
1538| |
1539| 1.81M| *++yyvsp = yyval;
1540| 1.81M| *++yylsp = yyloc;
1541| |
1542| | /* Now 'shift' the result of the reduction. Determine what state
1543| | that goes to, based on the state we popped back to and the rule
1544| | number reduced by. */
1545| 1.81M| {
1546| 1.81M| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 520| 1.81M|#define YYNTOKENS 6
------------------
1547| 1.81M| const int yyi = yypgoto[yylhs] + *yyssp;
1548| 1.81M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 517| 2.59M|#define YYLAST 7
------------------
| Branch (1548:16): [True: 781k, False: 1.03M]
| Branch (1548:28): [True: 781k, False: 0]
| Branch (1548:45): [True: 343k, False: 438k]
------------------
1549| 1.81M| ? yytable[yyi]
1550| 1.81M| : yydefgoto[yylhs]);
1551| 1.81M| }
1552| |
1553| 1.81M| goto yynewstate;
1554| |
1555| |
1556| |/*--------------------------------------.
1557| || yyerrlab -- here on detecting error. |
1558| |`--------------------------------------*/
1559| 0|yyerrlab:
1560| | /* Make sure we have latest lookahead translation. See comments at
1561| | user semantic actions for why this is necessary. */
1562| 0| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 673| 0|#define YYEMPTY (-2)
------------------
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 673| 0|#define YYEMPTY (-2)
------------------
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
------------------
| | 535| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 0|#define YYMAXUTOK 260
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 0, False: 0]
| | | Branch (535:18): [True: 0, False: 0]
| | ------------------
------------------
| Branch (1562:13): [True: 0, False: 0]
------------------
1563| |
1564| | /* If not already recovering from an error, report this error. */
1565| 0| if (!yyerrstatus)
------------------
| Branch (1565:7): [True: 0, False: 0]
------------------
1566| 0| {
1567| 0| ++yynerrs;
------------------
| | 71| 0|#define yynerrs igraph_ncol_yynerrs
------------------
1568| |#if ! YYERROR_VERBOSE
1569| | yyerror (&yylloc, context, YY_("syntax error"));
1570| |#else
1571| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1572| 0| yyssp, yytoken)
1573| 0| {
1574| 0| char const *yymsgp = YY_("syntax error");
------------------
| | 322| 0|# define YY_(Msgid) Msgid
------------------
1575| 0| int yysyntax_error_status;
1576| 0| yysyntax_error_status = YYSYNTAX_ERROR;
------------------
| | 1571| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
| | 1572| 0| yyssp, yytoken)
------------------
1577| 0| if (yysyntax_error_status == 0)
------------------
| Branch (1577:13): [True: 0, False: 0]
------------------
1578| 0| yymsgp = yymsg;
1579| 0| else if (yysyntax_error_status == 1)
------------------
| Branch (1579:18): [True: 0, False: 0]
------------------
1580| 0| {
1581| 0| if (yymsg != yymsgbuf)
------------------
| Branch (1581:17): [True: 0, False: 0]
------------------
1582| 0| YYSTACK_FREE (yymsg);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1583| 0| yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
------------------
| | 125| 0|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1584| 0| if (!yymsg)
------------------
| Branch (1584:17): [True: 0, False: 0]
------------------
1585| 0| {
1586| 0| yymsg = yymsgbuf;
1587| 0| yymsg_alloc = sizeof yymsgbuf;
1588| 0| yysyntax_error_status = 2;
1589| 0| }
1590| 0| else
1591| 0| {
1592| 0| yysyntax_error_status = YYSYNTAX_ERROR;
------------------
| | 1571| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
| | 1572| 0| yyssp, yytoken)
------------------
1593| 0| yymsgp = yymsg;
1594| 0| }
1595| 0| }
1596| 0| yyerror (&yylloc, context, yymsgp);
------------------
| | 69| 0|#define yyerror igraph_ncol_yyerror
------------------
1597| 0| if (yysyntax_error_status == 2)
------------------
| Branch (1597:13): [True: 0, False: 0]
------------------
1598| 0| goto yyexhaustedlab;
1599| 0| }
1600| 0|# undef YYSYNTAX_ERROR
1601| 0|#endif
1602| 0| }
1603| |
1604| 0| yyerror_range[1] = yylloc;
1605| |
1606| 0| if (yyerrstatus == 3)
------------------
| Branch (1606:7): [True: 0, False: 0]
------------------
1607| 0| {
1608| | /* If just tried and failed to reuse lookahead token after an
1609| | error, discard it. */
1610| |
1611| 0| if (yychar <= YYEOF)
------------------
| | 674| 0|#define YYEOF 0
------------------
| Branch (1611:11): [True: 0, False: 0]
------------------
1612| 0| {
1613| | /* Return failure if at end of input. */
1614| 0| if (yychar == YYEOF)
------------------
| | 674| 0|#define YYEOF 0
------------------
| Branch (1614:15): [True: 0, False: 0]
------------------
1615| 0| YYABORT;
------------------
| | 677| 0|#define YYABORT goto yyabortlab
------------------
1616| 0| }
1617| 0| else
1618| 0| {
1619| 0| yydestruct ("Error: discarding",
1620| 0| yytoken, &yylval, &yylloc, context);
1621| 0| yychar = YYEMPTY;
------------------
| | 673| 0|#define YYEMPTY (-2)
------------------
1622| 0| }
1623| 0| }
1624| |
1625| | /* Else will try to reuse lookahead token after shifting the error
1626| | token. */
1627| 0| goto yyerrlab1;
1628| |
1629| |
1630| |/*---------------------------------------------------.
1631| || yyerrorlab -- error raised explicitly by YYERROR. |
1632| |`---------------------------------------------------*/
1633| 0|yyerrorlab:
1634| | /* Pacify compilers when the user code never invokes YYERROR and the
1635| | label yyerrorlab therefore never appears in user code. */
1636| 0| if (0)
------------------
| Branch (1636:7): [Folded, False: 0]
------------------
1637| 0| YYERROR;
------------------
| | 678| 0|#define YYERROR goto yyerrorlab
------------------
1638| |
1639| | /* Do not reclaim the symbols of the rule whose action triggered
1640| | this YYERROR. */
1641| 0| YYPOPSTACK (yylen);
------------------
| | 1254| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1642| 0| yylen = 0;
1643| 0| YY_STACK_PRINT (yyss, yyssp);
1644| 0| yystate = *yyssp;
1645| 0| goto yyerrlab1;
1646| |
1647| |
1648| |/*-------------------------------------------------------------.
1649| || yyerrlab1 -- common code for both syntax error and YYERROR. |
1650| |`-------------------------------------------------------------*/
1651| 0|yyerrlab1:
1652| 0| yyerrstatus = 3; /* Each real token shifted decrements this. */
1653| |
1654| 0| for (;;)
1655| 0| {
1656| 0| yyn = yypact[yystate];
1657| 0| if (!yypact_value_is_default (yyn))
------------------
| | 601| 0| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 598| 0|#define YYPACT_NINF (-3)
| | ------------------
------------------
| Branch (1657:11): [True: 0, False: 0]
------------------
1658| 0| {
1659| 0| yyn += YYTERROR;
------------------
| | 701| 0|#define YYTERROR 1
------------------
1660| 0| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
------------------
| | 517| 0|#define YYLAST 7
------------------
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
------------------
| | 701| 0|#define YYTERROR 1
------------------
| Branch (1660:15): [True: 0, False: 0]
| Branch (1660:27): [True: 0, False: 0]
| Branch (1660:44): [True: 0, False: 0]
------------------
1661| 0| {
1662| 0| yyn = yytable[yyn];
1663| 0| if (0 < yyn)
------------------
| Branch (1663:19): [True: 0, False: 0]
------------------
1664| 0| break;
1665| 0| }
1666| 0| }
1667| |
1668| | /* Pop the current state because it cannot handle the error token. */
1669| 0| if (yyssp == yyss)
------------------
| Branch (1669:11): [True: 0, False: 0]
------------------
1670| 0| YYABORT;
------------------
| | 677| 0|#define YYABORT goto yyabortlab
------------------
1671| |
1672| 0| yyerror_range[1] = *yylsp;
1673| 0| yydestruct ("Error: popping",
1674| 0| yystos[yystate], yyvsp, yylsp, context);
1675| 0| YYPOPSTACK (1);
------------------
| | 1254| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1676| 0| yystate = *yyssp;
1677| 0| YY_STACK_PRINT (yyss, yyssp);
1678| 0| }
1679| |
1680| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1681| 0| *++yyvsp = yylval;
1682| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END
1683| |
1684| 0| yyerror_range[2] = yylloc;
1685| | /* Using YYLLOC is tempting, but would change the location of
1686| | the lookahead. YYLOC is available though. */
1687| 0| YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
------------------
| | 711| 0| do \
| | 712| 0| if (N) \
| | ------------------
| | | Branch (712:11): [True: 0, Folded]
| | ------------------
| | 713| 0| { \
| | 714| 0| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 729| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 715| 0| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 729| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 716| 0| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 729| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 717| 0| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 729| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 718| 0| } \
| | 719| 0| else \
| | 720| 0| { \
| | 721| 0| (Current).first_line = (Current).last_line = \
| | 722| 0| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 729| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 723| 0| (Current).first_column = (Current).last_column = \
| | 724| 0| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 729| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 725| 0| } \
| | 726| 0| while (0)
| | ------------------
| | | Branch (726:12): [Folded, False: 0]
| | ------------------
------------------
1688| 0| *++yylsp = yyloc;
1689| |
1690| | /* Shift the error token. */
1691| 0| YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1692| |
1693| 0| yystate = yyn;
1694| 0| goto yynewstate;
1695| |
1696| |
1697| |/*-------------------------------------.
1698| || yyacceptlab -- YYACCEPT comes here. |
1699| |`-------------------------------------*/
1700| 3.24k|yyacceptlab:
1701| 3.24k| yyresult = 0;
1702| 3.24k| goto yyreturn;
1703| |
1704| |
1705| |/*-----------------------------------.
1706| || yyabortlab -- YYABORT comes here. |
1707| |`-----------------------------------*/
1708| 0|yyabortlab:
1709| 0| yyresult = 1;
1710| 0| goto yyreturn;
1711| |
1712| |
1713| 0|#if !defined yyoverflow || YYERROR_VERBOSE
1714| |/*-------------------------------------------------.
1715| || yyexhaustedlab -- memory exhaustion comes here. |
1716| |`-------------------------------------------------*/
1717| 0|yyexhaustedlab:
1718| 0| yyerror (&yylloc, context, YY_("memory exhausted"));
------------------
| | 69| 0|#define yyerror igraph_ncol_yyerror
------------------
yyerror (&yylloc, context, YY_("memory exhausted"));
------------------
| | 322| 0|# define YY_(Msgid) Msgid
------------------
1719| 0| yyresult = 2;
1720| | /* Fall through. */
1721| 0|#endif
1722| |
1723| |
1724| |/*-----------------------------------------------------.
1725| || yyreturn -- parsing is finished, return the result. |
1726| |`-----------------------------------------------------*/
1727| 3.24k|yyreturn:
1728| 3.24k| if (yychar != YYEMPTY)
------------------
| | 673| 3.24k|#define YYEMPTY (-2)
------------------
| Branch (1728:7): [True: 0, False: 3.24k]
------------------
1729| 0| {
1730| | /* Make sure we have latest lookahead translation. See comments at
1731| | user semantic actions for why this is necessary. */
1732| 0| yytoken = YYTRANSLATE (yychar);
------------------
| | 535| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 0|#define YYMAXUTOK 260
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 0, False: 0]
| | | Branch (535:18): [True: 0, False: 0]
| | ------------------
------------------
1733| 0| yydestruct ("Cleanup: discarding lookahead",
1734| 0| yytoken, &yylval, &yylloc, context);
1735| 0| }
1736| | /* Do not reclaim the symbols of the rule whose action triggered
1737| | this YYABORT or YYACCEPT. */
1738| 3.24k| YYPOPSTACK (yylen);
------------------
| | 1254| 3.24k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1739| 3.24k| YY_STACK_PRINT (yyss, yyssp);
1740| 9.74k| while (yyssp != yyss)
------------------
| Branch (1740:10): [True: 6.49k, False: 3.24k]
------------------
1741| 6.49k| {
1742| 6.49k| yydestruct ("Cleanup: popping",
1743| 6.49k| yystos[+*yyssp], yyvsp, yylsp, context);
1744| 6.49k| YYPOPSTACK (1);
------------------
| | 1254| 6.49k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1745| 6.49k| }
1746| 3.24k|#ifndef yyoverflow
1747| 3.24k| if (yyss != yyssa)
------------------
| Branch (1747:7): [True: 0, False: 3.24k]
------------------
1748| 0| YYSTACK_FREE (yyss);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1749| 3.24k|#endif
1750| 3.24k|#if YYERROR_VERBOSE
1751| 3.24k| if (yymsg != yymsgbuf)
------------------
| Branch (1751:7): [True: 0, False: 3.24k]
------------------
1752| 0| YYSTACK_FREE (yymsg);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1753| 3.24k|#endif
1754| 3.24k| return yyresult;
1755| 0|}
ncol-parser.c:yydestruct:
1162| 6.49k|{
1163| 6.49k| YYUSE (yyvaluep);
------------------
| | 344| 6.49k|# define YYUSE(E) ((void) (E))
------------------
1164| 6.49k| YYUSE (yylocationp);
------------------
| | 344| 6.49k|# define YYUSE(E) ((void) (E))
------------------
1165| 6.49k| YYUSE (context);
------------------
| | 344| 6.49k|# define YYUSE(E) ((void) (E))
------------------
1166| 6.49k| if (!yymsg)
------------------
| Branch (1166:7): [True: 0, False: 6.49k]
------------------
1167| 0| yymsg = "Deleting";
1168| 6.49k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1169| |
1170| 6.49k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1171| 6.49k| YYUSE (yytype);
------------------
| | 344| 6.49k|# define YYUSE(E) ((void) (E))
------------------
1172| 6.49k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1173| 6.49k|}
LLVMFuzzerTestOneInput:
36| 19.8k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
37| |
38| 19.8k| igraph_set_error_handler(igraph_error_handler_ignore);
39| 19.8k| igraph_set_warning_handler(igraph_warning_handler_ignore);
40| |
41| | // Turn on attribute handling
42| 19.8k| igraph_set_attribute_table(&igraph_cattribute_table);
43| |
44| | // Read input file
45| 19.8k| FILE *ifile = fmemopen((void*) data, size, "r");
46| 19.8k| if (!ifile) {
------------------
| Branch (46:9): [True: 0, False: 19.8k]
------------------
47| 0| return 0;
48| 0| }
49| |
50| | // Do the fuzzing
51| 19.8k| igraph_t g;
52| 19.8k| if (igraph_read_graph_graphml(&g, ifile, 0) == IGRAPH_SUCCESS) {
------------------
| Branch (52:9): [True: 3.34k, False: 16.5k]
------------------
53| 3.34k| FILE *file;
54| 3.34k| igraph_t g2;
55| |
56| 3.34k| file = tmpfile();
57| 3.34k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.34k| do { \
| | 925| 3.34k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.34k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.34k]
| | ------------------
------------------
58| | // Do not check error because:
59| | // "Vertex attribute values cannot contain newline characters."
60| 3.34k| igraph_write_graph_leda(&g, file, "label", "weight");
61| 3.34k| fclose(file);
62| |
63| 3.34k| file = tmpfile();
64| 3.34k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.34k| do { \
| | 925| 3.34k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.34k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.34k]
| | ------------------
------------------
65| 3.34k| CHECK_ERR(igraph_write_graph_dot(&g, file));
------------------
| | 29| 3.34k| do { \
| | 30| 3.34k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.34k| expr; \
| | 32| 3.34k| igraph_set_error_handler(handler); \
| | 33| 3.34k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.34k]
| | ------------------
------------------
66| 3.34k| fclose(file);
67| |
68| 3.34k| file = tmpfile();
69| 3.34k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.34k| do { \
| | 925| 3.34k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.34k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.34k]
| | ------------------
------------------
70| 3.34k| CHECK_ERR(igraph_write_graph_gml(&g, file, IGRAPH_WRITE_GML_DEFAULT_SW, NULL, "no one"));
------------------
| | 29| 3.34k| do { \
| | 30| 3.34k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.34k| expr; \
| | 32| 3.34k| igraph_set_error_handler(handler); \
| | 33| 3.34k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.34k]
| | ------------------
------------------
71| 3.34k| rewind(file);
72| 3.34k| CHECK_ERR(igraph_read_graph_gml(&g2, file));
------------------
| | 29| 3.34k| do { \
| | 30| 3.34k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.34k| expr; \
| | 32| 3.34k| igraph_set_error_handler(handler); \
| | 33| 3.34k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.34k]
| | ------------------
------------------
73| 3.34k| igraph_destroy(&g2);
74| 3.34k| fclose(file);
75| |
76| | // Reading Pajek files back is disabled because of
77| | // https://github.com/igraph/igraph/issues/2560
78| 3.34k| file = tmpfile();
79| 3.34k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.34k| do { \
| | 925| 3.34k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.34k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.34k]
| | ------------------
------------------
80| 3.34k| CHECK_ERR(igraph_write_graph_pajek(&g, file));
------------------
| | 29| 3.34k| do { \
| | 30| 3.34k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.34k| expr; \
| | 32| 3.34k| igraph_set_error_handler(handler); \
| | 33| 3.34k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.34k]
| | ------------------
------------------
81| | /*
82| | rewind(file);
83| | CHECK_ERR(igraph_read_graph_pajek(&g2, file));
84| | igraph_destroy(&g2);
85| | */
86| 3.34k| fclose(file);
87| |
88| 3.34k| file = tmpfile();
89| 3.34k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.34k| do { \
| | 925| 3.34k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.34k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.34k]
| | ------------------
------------------
90| | // Do not check error when writing GraphML because string attributes
91| | // may contain forbidden control characters.
92| 3.34k| if (igraph_write_graph_graphml(&g, file, false) == IGRAPH_SUCCESS) {
------------------
| Branch (92:13): [True: 3.34k, False: 0]
------------------
93| 3.34k| rewind(file);
94| | // Do not check error when reading because strings may not be
95| | // in a valid encoding, which confuses libxml2.
96| 3.34k| if (igraph_read_graph_graphml(&g2, file, 0) == IGRAPH_SUCCESS) {
------------------
| Branch (96:17): [True: 3.30k, False: 39]
------------------
97| 3.30k| igraph_destroy(&g2);
98| 3.30k| }
99| 3.34k| }
100| 3.34k| fclose(file);
101| |
102| 3.34k| file = tmpfile();
103| 3.34k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.34k| do { \
| | 925| 3.34k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.34k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.34k]
| | ------------------
------------------
104| | // Do not check error when writing LGL because not all possible
105| | // vertex names are supported by this format.
106| 3.34k| if (igraph_write_graph_lgl(&g, file, "label", "weight", false) == IGRAPH_SUCCESS) {
------------------
| Branch (106:13): [True: 3.19k, False: 148]
------------------
107| 3.19k| rewind(file);
108| 3.19k| CHECK_ERR(igraph_read_graph_lgl(&g2, file, true, IGRAPH_ADD_WEIGHTS_IF_PRESENT, true));
------------------
| | 29| 3.19k| do { \
| | 30| 3.19k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.19k| expr; \
| | 32| 3.19k| igraph_set_error_handler(handler); \
| | 33| 3.19k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.19k]
| | ------------------
------------------
109| 3.19k| igraph_destroy(&g2);
110| 3.19k| }
111| 3.34k| fclose(file);
112| |
113| 3.34k| file = tmpfile();
114| 3.34k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.34k| do { \
| | 925| 3.34k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.34k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.34k]
| | ------------------
------------------
115| | // Do not check error when writing NCOL because not all possible
116| | // vertex names are supported by this format.
117| 3.34k| if (igraph_write_graph_ncol(&g, file, "label", "weight") == IGRAPH_SUCCESS) {
------------------
| Branch (117:13): [True: 3.24k, False: 91]
------------------
118| 3.24k| rewind(file);
119| 3.24k| CHECK_ERR(igraph_read_graph_ncol(&g2, file, NULL, true, IGRAPH_ADD_WEIGHTS_IF_PRESENT, true));
------------------
| | 29| 3.24k| do { \
| | 30| 3.24k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.24k| expr; \
| | 32| 3.24k| igraph_set_error_handler(handler); \
| | 33| 3.24k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.24k]
| | ------------------
------------------
120| 3.24k| igraph_destroy(&g2);
121| 3.24k| }
122| 3.34k| fclose(file);
123| |
124| | // Clean up
125| 3.34k| igraph_destroy(&g);
126| 3.34k| }
127| |
128| | // no need to call igraph_destroy() if igraph_read_graph_graphml() returns an
129| | // error code as we don't have a valid graph object in that case
130| |
131| 19.8k| fclose(ifile);
132| |
133| 19.8k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY);
------------------
| | 924| 19.8k| do { \
| | 925| 19.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 19.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 19.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 19.8k]
| | ------------------
------------------
134| |
135| 19.8k| return 0;
136| 19.8k|}
igraph_error:
210| 18.3k| igraph_error_t igraph_errno) {
211| |
212| 18.3k| if (igraph_i_error_handler) {
------------------
| Branch (212:9): [True: 18.3k, False: 0]
------------------
213| 18.3k| igraph_i_error_handler(reason, file, line, igraph_errno);
214| 18.3k|#ifndef USING_R
215| 18.3k| } else {
216| 0| igraph_error_handler_abort(reason, file, line, igraph_errno);
217| 0|#endif
218| 0| }
219| 18.3k| return igraph_errno;
220| 18.3k|}
igraph_errorf:
240| 559| igraph_error_t igraph_errno, ...) {
241| 559| va_list ap;
242| 559| va_start(ap, igraph_errno);
243| 559| vsnprintf(igraph_i_errormsg_buffer,
244| 559| sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap);
245| | va_end(ap);
246| 559| return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno);
247| 559|}
igraph_error_handler_ignore:
266| 18.3k| int line, igraph_error_t igraph_errno) {
267| 18.3k| IGRAPH_UNUSED(reason);
------------------
| | 30| 18.3k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
268| 18.3k| IGRAPH_UNUSED(file);
------------------
| | 30| 18.3k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
269| 18.3k| IGRAPH_UNUSED(line);
------------------
| | 30| 18.3k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
270| 18.3k| IGRAPH_UNUSED(igraph_errno);
------------------
| | 30| 18.3k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
271| |
272| 18.3k| IGRAPH_FINALLY_FREE();
273| 18.3k|}
igraph_set_error_handler:
298| 59.4k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) {
299| 59.4k| igraph_error_handler_t *previous_handler = igraph_i_error_handler;
300| 59.4k| igraph_i_error_handler = new_handler;
301| 59.4k| return previous_handler;
302| 59.4k|}
IGRAPH_FINALLY_REAL:
320| 14.2M|void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) {
321| 14.2M| int no = igraph_i_finally_stack_size;
322| 14.2M| if (no < 0) {
------------------
| Branch (322:9): [True: 0, False: 14.2M]
------------------
323| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */
324| 0| igraph_i_reset_finally_stack();
325| 0| IGRAPH_FATALF("Corrupt finally stack: it contains %d elements.", no);
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
326| 0| }
327| 14.2M| if (no >= (int) (sizeof(igraph_i_finally_stack) / sizeof(igraph_i_finally_stack[0]))) {
------------------
| Branch (327:9): [True: 0, False: 14.2M]
------------------
328| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */
329| 0| igraph_i_reset_finally_stack();
330| 0| IGRAPH_FATALF("Finally stack too large: it contains %d elements.", no);
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
331| 0| }
332| 14.2M| igraph_i_finally_stack[no].ptr = ptr;
333| 14.2M| igraph_i_finally_stack[no].func = func;
334| 14.2M| igraph_i_finally_stack[no].level = igraph_i_finally_stack_level;
335| 14.2M| igraph_i_finally_stack_size++;
336| 14.2M|}
IGRAPH_FINALLY_CLEAN:
338| 8.73M|void IGRAPH_FINALLY_CLEAN(int minus) {
339| 8.73M| igraph_i_finally_stack_size -= minus;
340| 8.73M| if (igraph_i_finally_stack_size < 0) {
------------------
| Branch (340:9): [True: 0, False: 8.73M]
------------------
341| 0| int left = igraph_i_finally_stack_size + minus;
342| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */
343| 0| igraph_i_reset_finally_stack();
344| 0| IGRAPH_FATALF("Corrupt finally stack: trying to pop %d element(s) when only %d left.", minus, left);
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
345| 0| }
346| 8.73M|}
IGRAPH_FINALLY_FREE:
348| 18.3k|void IGRAPH_FINALLY_FREE(void) {
349| 53.2k| for (; igraph_i_finally_stack_size > 0; igraph_i_finally_stack_size--) {
------------------
| Branch (349:12): [True: 36.0k, False: 17.1k]
------------------
350| 36.0k| int p = igraph_i_finally_stack_size - 1;
351| | /* Call destructors only up to the current level */
352| 36.0k| if (igraph_i_finally_stack[p].level < igraph_i_finally_stack_level) {
------------------
| Branch (352:13): [True: 1.20k, False: 34.8k]
------------------
353| 1.20k| break;
354| 1.20k| }
355| 34.8k| igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr);
356| 34.8k| }
357| 18.3k|}
IGRAPH_FINALLY_STACK_SIZE:
359| 19.8k|int IGRAPH_FINALLY_STACK_SIZE(void) {
360| 19.8k| return igraph_i_finally_stack_size;
361| 19.8k|}
IGRAPH_FINALLY_ENTER:
377| 2.55M|void IGRAPH_FINALLY_ENTER(void) {
378| 2.55M| int no = igraph_i_finally_stack_size;
379| | /* Level indices must always be in increasing order in the finally stack */
380| 2.55M| if (no > 0 && igraph_i_finally_stack[no-1].level > igraph_i_finally_stack_level) {
------------------
| Branch (380:9): [True: 2.55M, False: 0]
| Branch (380:19): [True: 0, False: 2.55M]
------------------
381| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */
382| 0| igraph_i_reset_finally_stack();
383| 0| IGRAPH_FATAL("Corrupt finally stack: cannot create new finally stack level before last one is freed.");
------------------
| | 895| 0| do { \
| | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 897| 0| } while (0)
| | ------------------
| | | Branch (897:14): [Folded, False: 0]
| | ------------------
------------------
384| 0| }
385| 2.55M| igraph_i_finally_stack_level++;
386| 2.55M|}
IGRAPH_FINALLY_EXIT:
399| 2.55M|void IGRAPH_FINALLY_EXIT(void) {
400| 2.55M| igraph_i_finally_stack_level--;
401| 2.55M| if (igraph_i_finally_stack_level < 0) {
------------------
| Branch (401:9): [True: 0, False: 2.55M]
------------------
402| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */
403| 0| igraph_i_reset_finally_stack();
404| 0| IGRAPH_FATAL("Corrupt finally stack: trying to exit outermost finally stack level.");
------------------
| | 895| 0| do { \
| | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 897| 0| } while (0)
| | ------------------
| | | Branch (897:14): [Folded, False: 0]
| | ------------------
------------------
405| 0| }
406| 2.55M|}
igraph_warning_handler_ignore:
424| 53.3k|void igraph_warning_handler_ignore(const char *reason, const char *file, int line) {
425| 53.3k| IGRAPH_UNUSED(reason);
------------------
| | 30| 53.3k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
426| 53.3k| IGRAPH_UNUSED(file);
------------------
| | 30| 53.3k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
427| 53.3k| IGRAPH_UNUSED(line);
------------------
| | 30| 53.3k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
428| 53.3k|}
igraph_warning:
463| 53.3k|void igraph_warning(const char *reason, const char *file, int line) {
464| |
465| 53.3k| if (igraph_i_warning_handler) {
------------------
| Branch (465:9): [True: 53.3k, False: 0]
------------------
466| 53.3k| igraph_i_warning_handler(reason, file, line);
467| 53.3k|#ifndef USING_R
468| 53.3k| } else {
469| 0| igraph_warning_handler_print(reason, file, line);
470| 0|#endif
471| 0| }
472| 53.3k|}
igraph_warningf:
492| 38.1k|void igraph_warningf(const char *reason, const char *file, int line, ...) {
493| 38.1k| va_list ap;
494| 38.1k| va_start(ap, line);
495| 38.1k| vsnprintf(igraph_i_warningmsg_buffer,
496| 38.1k| sizeof(igraph_i_warningmsg_buffer) / sizeof(char), reason, ap);
497| | va_end(ap);
498| 38.1k| igraph_warning(igraph_i_warningmsg_buffer, file, line);
499| 38.1k|}
igraph_set_warning_handler:
514| 19.8k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) {
515| 19.8k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler;
516| 19.8k| igraph_i_warning_handler = new_handler;
517| 19.8k| return previous_handler;
518| 19.8k|}
igraph_free:
62| 184k|void igraph_free(void *ptr) {
63| | IGRAPH_FREE(ptr);
------------------
| | 36| 184k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
64| 184k|}
igraph_real_fprintf_precise:
117| 388k|int igraph_real_fprintf_precise(FILE *file, igraph_real_t val) {
118| 388k| if (isfinite(val)) {
------------------
| Branch (118:9): [True: 9.25k, False: 379k]
------------------
119| 9.25k| return fprintf(file, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
------------------
| | 54| 9.25k| #define IGRAPH_REAL_PRINTF_PRECISE_FORMAT "%." IGRAPH_I_STRINGIFY(DBL_DIG) "g"
------------------
120| 379k| } else if (isnan(val)) {
------------------
| Branch (120:16): [True: 379k, False: 0]
------------------
121| 379k| return fprintf(file, "NaN");
122| 379k| } else if (isinf(val)) {
------------------
| Branch (122:16): [True: 0, False: 0]
------------------
123| 0| if (val < 0) {
------------------
| Branch (123:13): [True: 0, False: 0]
------------------
124| 0| return fprintf(file, "-Inf");
125| 0| } else {
126| 0| return fprintf(file, "Inf");
127| 0| }
128| 0| }
129| 0| IGRAPH_FATAL("Value is not finite, not infinite and not NaN either!"); /* LCOV_EXCL_LINE */
------------------
| | 895| 0| do { \
| | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 897| 0| } while (0)
| | ------------------
| | | Branch (897:14): [Folded, False: 0]
| | ------------------
------------------
130| 0|}
igraph_real_snprintf_precise:
138| 99.7k|int igraph_real_snprintf_precise(char *str, size_t size, igraph_real_t val) {
139| 99.7k| if (isfinite(val)) {
------------------
| Branch (139:9): [True: 1.42k, False: 98.3k]
------------------
140| 1.42k| return snprintf(str, size, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
------------------
| | 54| 1.42k| #define IGRAPH_REAL_PRINTF_PRECISE_FORMAT "%." IGRAPH_I_STRINGIFY(DBL_DIG) "g"
------------------
141| 98.3k| } else if (isnan(val)) {
------------------
| Branch (141:16): [True: 98.3k, False: 0]
------------------
142| 98.3k| return snprintf(str, size, "NaN");
143| 98.3k| } else if (isinf(val)) {
------------------
| Branch (143:16): [True: 0, False: 0]
------------------
144| 0| if (val < 0) {
------------------
| Branch (144:13): [True: 0, False: 0]
------------------
145| 0| return snprintf(str, size, "-Inf");
146| 0| } else {
147| 0| return snprintf(str, size, "Inf");
148| 0| }
149| 0| }
150| 0| IGRAPH_FATAL("Value is not finite, not infinite and not NaN either!"); /* LCOV_EXCL_LINE */
------------------
| | 895| 0| do { \
| | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 897| 0| } while (0)
| | ------------------
| | | Branch (897:14): [Folded, False: 0]
| | ------------------
------------------
151| 0|}
igraph_strvector_init:
71| 281k|igraph_error_t igraph_strvector_init(igraph_strvector_t *sv, igraph_int_t size) {
72| |
73| 281k| sv->stor_begin = IGRAPH_CALLOC(size, const char *);
------------------
| | 33| 281k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 562k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 281k, False: 0]
| | | | | Branch (31:24): [True: 281k, False: 0]
| | | | | Branch (31:66): [True: 36.7k, False: 244k]
| | | | ------------------
| | ------------------
------------------
74| 281k| IGRAPH_CHECK_OOM(sv->stor_begin, "Cannot initialize string vector.");
------------------
| | 709| 281k| do { \
| | 710| 281k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 281k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 281k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 281k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 281k]
| | ------------------
------------------
75| |
76| 281k| sv->stor_end = sv->stor_begin + size;
77| 281k| sv->end = sv->stor_end;
78| |
79| 281k| return IGRAPH_SUCCESS;
80| 281k|}
igraph_strvector_destroy:
95| 281k|void igraph_strvector_destroy(igraph_strvector_t *sv) {
96| 281k| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 281k| do { \
| | 925| 281k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 281k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 281k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 281k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 281k]
| | ------------------
------------------
97| 281k| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 281k| do { \
| | 925| 281k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 281k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 281k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 281k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 281k]
| | ------------------
------------------
98| 3.30M| for (const char **ptr = sv->stor_begin; ptr < sv->end; ptr++) {
------------------
| Branch (98:45): [True: 3.01M, False: 281k]
------------------
99| 3.01M| IGRAPH_FREE(*ptr);
------------------
| | 36| 3.01M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
100| 3.01M| }
101| | IGRAPH_FREE(sv->stor_begin);
------------------
| | 36| 281k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
102| 281k|}
igraph_strvector_get:
117| 20.9M|const char *igraph_strvector_get(const igraph_strvector_t *sv, igraph_int_t idx) {
118| 20.9M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 20.9M| do { \
| | 925| 20.9M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 20.9M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 20.9M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 20.9M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 20.9M]
| | ------------------
------------------
119| 20.9M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 20.9M| do { \
| | 925| 20.9M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 20.9M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 20.9M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 20.9M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 20.9M]
| | ------------------
------------------
120| 20.9M| return sv->stor_begin[idx] ? sv->stor_begin[idx] : "";
------------------
| Branch (120:12): [True: 20.5M, False: 383k]
------------------
121| 20.9M|}
igraph_strvector_set:
141| 2.31M| const char *value) {
142| 2.31M| return igraph_strvector_set_len(sv, idx, value, strlen(value));
143| 2.31M|}
igraph_strvector_set_len:
163| 2.31M| const char *value, size_t len) {
164| 2.31M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 2.31M| do { \
| | 925| 2.31M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.31M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.31M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.31M]
| | ------------------
------------------
165| 2.31M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 2.31M| do { \
| | 925| 2.31M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.31M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.31M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.31M]
| | ------------------
------------------
166| |
167| 2.31M| if (sv->stor_begin[idx] == NULL) {
------------------
| Branch (167:9): [True: 2.29M, False: 17.0k]
------------------
168| 2.29M| sv->stor_begin[idx] = strndup(value, len);
169| 2.29M| IGRAPH_CHECK_OOM(sv->stor_begin[idx], "Cannot reserve space for new item in string vector.");
------------------
| | 709| 2.29M| do { \
| | 710| 2.29M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 2.29M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.29M]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 2.29M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 2.29M]
| | ------------------
------------------
170| 2.29M| } else {
171| 17.0k| char *tmp = IGRAPH_REALLOC(sv->stor_begin[idx], len + 1, char);
------------------
| | 35| 17.0k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 34.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 17.0k, False: 0]
| | | | | Branch (31:24): [True: 17.0k, False: 0]
| | | | | Branch (31:66): [True: 17.0k, False: 0]
| | | | ------------------
| | ------------------
------------------
172| 17.0k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new item in string vector.");
------------------
| | 709| 17.0k| do { \
| | 710| 17.0k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 17.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.0k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 17.0k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 17.0k]
| | ------------------
------------------
173| |
174| 17.0k| memcpy(tmp, value, len * sizeof(char));
175| 17.0k| tmp[len] = '\0';
176| 17.0k| sv->stor_begin[idx] = tmp;
177| 17.0k| }
178| |
179| 2.31M| return IGRAPH_SUCCESS;
180| 2.31M|}
igraph_strvector_append:
300| 34.7k| const igraph_strvector_t *from) {
301| 34.7k| const igraph_int_t to_size = igraph_strvector_size(to);
302| 34.7k| const igraph_int_t from_size = igraph_strvector_size(from);
303| 34.7k| const igraph_int_t to_capacity = igraph_strvector_capacity(to);
304| 34.7k| igraph_int_t new_to_size;
305| 34.7k| igraph_bool_t error = false;
306| 34.7k| const char *tmp;
307| |
308| 34.7k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 34.7k| do { \
| | 48| 34.7k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 34.7k| igraph_int_t _safe_sum; \
| | 50| 34.7k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 34.7k]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 34.7k| *(res) = _safe_sum; \
| | 54| 34.7k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 34.7k]
| | ------------------
------------------
309| |
310| 34.7k| if (to_capacity < new_to_size) {
------------------
| Branch (310:9): [True: 27.1k, False: 7.60k]
------------------
311| 27.1k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 27.1k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 27.1k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (311:40): [True: 27.1k, False: 0]
------------------
312| 27.1k| if (new_to_capacity < new_to_size) {
------------------
| Branch (312:13): [True: 27.1k, False: 5]
------------------
313| 27.1k| new_to_capacity = new_to_size;
314| 27.1k| }
315| 27.1k| IGRAPH_CHECK(igraph_strvector_reserve(to, new_to_capacity));
------------------
| | 656| 27.1k| do { \
| | 657| 27.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 27.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27.1k]
| | ------------------
------------------
316| 27.1k| }
317| |
318| 1.57M| for (igraph_int_t i = 0; i < from_size; i++) {
------------------
| Branch (318:30): [True: 1.53M, False: 34.7k]
------------------
319| 1.53M| if (from->stor_begin[i] == NULL || from->stor_begin[i][0] == '\0') {
------------------
| Branch (319:13): [True: 158k, False: 1.37M]
| Branch (319:44): [True: 265k, False: 1.11M]
------------------
320| | /* Represent empty strings as NULL. */
321| 423k| tmp = NULL;
322| 1.11M| } else {
323| 1.11M| tmp = strdup(from->stor_begin[i]);
324| 1.11M| if (tmp == NULL) {
------------------
| Branch (324:17): [True: 0, False: 1.11M]
------------------
325| 0| error = true;
326| 0| break;
327| 0| }
328| 1.11M| }
329| 1.53M| *(to->end) = tmp;
330| 1.53M| to->end++;
331| 1.53M| }
332| |
333| 34.7k| if (error) {
------------------
| Branch (333:9): [True: 0, False: 34.7k]
------------------
334| 0| igraph_strvector_resize(to, to_size); /* always shrinks */
335| 0| IGRAPH_ERROR("Cannot append string vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
336| 0| }
337| |
338| 34.7k| return IGRAPH_SUCCESS;
339| 34.7k|}
igraph_strvector_clear:
393| 1.18M|void igraph_strvector_clear(igraph_strvector_t *sv) {
394| 1.18M| igraph_int_t n = igraph_strvector_size(sv);
395| |
396| 2.36M| for (igraph_int_t i = 0; i < n; i++) {
------------------
| Branch (396:30): [True: 1.18M, False: 1.18M]
------------------
397| | IGRAPH_FREE(sv->stor_begin[i]);
------------------
| | 36| 1.18M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
398| 1.18M| }
399| 1.18M| sv->end = sv->stor_begin;
400| 1.18M|}
igraph_strvector_resize:
419| 4.09M|igraph_error_t igraph_strvector_resize(igraph_strvector_t *sv, igraph_int_t newsize) {
420| 4.09M| igraph_int_t toadd = newsize - igraph_strvector_size(sv);
421| 4.09M| igraph_int_t oldsize = igraph_strvector_size(sv);
422| |
423| 4.09M| if (newsize < oldsize) {
------------------
| Branch (423:9): [True: 2.35M, False: 1.74M]
------------------
424| 4.70M| for (igraph_int_t i = newsize; i < oldsize; i++) {
------------------
| Branch (424:40): [True: 2.35M, False: 2.35M]
------------------
425| 2.35M| IGRAPH_FREE(sv->stor_begin[i]);
------------------
| | 36| 2.35M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
426| 2.35M| }
427| 2.35M| sv->end = sv->stor_begin + newsize;
428| 2.35M| } else if (newsize > oldsize) {
------------------
| Branch (428:16): [True: 1.72M, False: 20.7k]
------------------
429| 1.72M| IGRAPH_CHECK(igraph_strvector_reserve(sv, newsize));
------------------
| | 656| 1.72M| do { \
| | 657| 1.72M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.72M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.72M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.72M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.72M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.72M]
| | ------------------
------------------
430| 1.72M| memset(sv->stor_begin + oldsize, 0, toadd * sizeof(const char *));
431| 1.72M| sv->end = sv->stor_begin + newsize;
432| 1.72M| }
433| |
434| 4.09M| return IGRAPH_SUCCESS;
435| 4.09M|}
igraph_strvector_capacity:
448| 1.90M|igraph_int_t igraph_strvector_capacity(const igraph_strvector_t *sv) {
449| 1.90M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 1.90M| do { \
| | 925| 1.90M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.90M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.90M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.90M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.90M]
| | ------------------
------------------
450| 1.90M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 1.90M| do { \
| | 925| 1.90M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.90M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.90M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.90M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.90M]
| | ------------------
------------------
451| 1.90M| return sv->stor_end - sv->stor_begin;
452| 1.90M|}
igraph_strvector_reserve:
481| 1.87M|igraph_error_t igraph_strvector_reserve(igraph_strvector_t *sv, igraph_int_t capacity) {
482| 1.87M| igraph_int_t current_capacity = igraph_strvector_capacity(sv);
483| |
484| 1.87M| if (capacity <= current_capacity) {
------------------
| Branch (484:9): [True: 1.16M, False: 712k]
------------------
485| 1.16M| return IGRAPH_SUCCESS;
486| 1.16M| }
487| |
488| 712k| const char **tmp = IGRAPH_REALLOC(sv->stor_begin, capacity, const char *);
------------------
| | 35| 712k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 1.42M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 712k, False: 0]
| | | | | Branch (31:24): [True: 712k, False: 0]
| | | | | Branch (31:66): [True: 712k, False: 0]
| | | | ------------------
| | ------------------
------------------
489| 712k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new items in string vector.");
------------------
| | 709| 712k| do { \
| | 710| 712k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 712k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 712k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 712k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 712k]
| | ------------------
------------------
490| |
491| 712k| sv->end = tmp + (sv->end - sv->stor_begin);
492| 712k| sv->stor_begin = tmp;
493| 712k| sv->stor_end = sv->stor_begin + capacity;
494| |
495| 712k| return IGRAPH_SUCCESS;
496| 712k|}
igraph_strvector_size:
538| 16.2M|igraph_int_t igraph_strvector_size(const igraph_strvector_t *sv) {
539| 16.2M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 16.2M| do { \
| | 925| 16.2M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.2M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.2M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.2M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.2M]
| | ------------------
------------------
540| 16.2M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 16.2M| do { \
| | 925| 16.2M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.2M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.2M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.2M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.2M]
| | ------------------
------------------
541| 16.2M| return sv->end - sv->stor_begin;
542| 16.2M|}
igraph_strvector_push_back:
580| 2.61M|igraph_error_t igraph_strvector_push_back(igraph_strvector_t *sv, const char *value) {
581| 2.61M| IGRAPH_CHECK(strvector_expand_if_full(sv));
------------------
| | 656| 2.61M| do { \
| | 657| 2.61M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.61M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.61M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.61M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.61M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.61M]
| | ------------------
------------------
582| 2.61M| const char *tmp = strdup(value);
583| 2.61M| IGRAPH_CHECK_OOM(tmp, "Cannot push new string to string vector.");
------------------
| | 709| 2.61M| do { \
| | 710| 2.61M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 2.61M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.61M]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 2.61M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 2.61M]
| | ------------------
------------------
584| 2.61M| *sv->end = tmp;
585| 2.61M| sv->end++;
586| |
587| 2.61M| return IGRAPH_SUCCESS;
588| 2.61M|}
igraph_strvector_update:
698| 12.3k|) {
699| 12.3k| igraph_strvector_clear(to);
700| 12.3k| IGRAPH_CHECK(igraph_strvector_append(to, from));
------------------
| | 656| 12.3k| do { \
| | 657| 12.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 12.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 12.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 12.3k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 12.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 12.3k]
| | ------------------
------------------
701| 12.3k| return IGRAPH_SUCCESS;
702| 12.3k|}
strvector.c:strvector_expand_if_full:
548| 2.61M|static igraph_error_t strvector_expand_if_full(igraph_strvector_t *sv) {
549| 2.61M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 2.61M| do { \
| | 925| 2.61M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.61M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.61M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.61M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.61M]
| | ------------------
------------------
550| 2.61M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 2.61M| do { \
| | 925| 2.61M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.61M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.61M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.61M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.61M]
| | ------------------
------------------
551| |
552| 2.61M| if (sv->stor_end == sv->end) {
------------------
| Branch (552:9): [True: 126k, False: 2.49M]
------------------
553| 126k| igraph_int_t old_size = igraph_strvector_size(sv);
554| 126k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 126k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 126k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (554:33): [True: 126k, False: 0]
------------------
555| 126k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 126k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (555:13): [True: 0, False: 126k]
------------------
556| 0| IGRAPH_ERROR("Cannot add new item to string vector, already at maximum size.", IGRAPH_EOVERFLOW);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
557| 0| }
558| 126k| if (new_size == 0) {
------------------
| Branch (558:13): [True: 36.5k, False: 89.9k]
------------------
559| 36.5k| new_size = 1;
560| 36.5k| }
561| 126k| IGRAPH_CHECK(igraph_strvector_reserve(sv, new_size));
------------------
| | 656| 126k| do { \
| | 657| 126k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 126k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 126k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 126k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 126k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 126k]
| | ------------------
------------------
562| 126k| }
563| |
564| 2.61M| return IGRAPH_SUCCESS;
565| 2.61M|}
igraph_trie_init:
61| 112k|igraph_error_t igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) {
62| 112k| t->maxvalue = -1;
63| 112k| t->storekeys = storekeys;
64| 112k| IGRAPH_CHECK(igraph_i_trie_init_node(&t->node));
------------------
| | 656| 112k| do { \
| | 657| 112k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 112k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 112k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 112k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 112k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 112k]
| | ------------------
------------------
65| 112k| IGRAPH_FINALLY(igraph_i_trie_destroy_node, &t->node);
------------------
| | 603| 112k| do { \
| | 604| 112k| /* the following branch makes the compiler check the compatibility of \
| | 605| 112k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 112k| * incorrect destructor function with the pointer */ \
| | 607| 112k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 112k]
| | ------------------
| | 608| 112k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 112k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 112k]
| | ------------------
------------------
66| 112k| if (storekeys) {
------------------
| Branch (66:9): [True: 29.6k, False: 82.9k]
------------------
67| 29.6k| IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0));
------------------
| | 656| 29.6k| do { \
| | 657| 29.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 29.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 29.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 29.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 29.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 29.6k]
| | ------------------
------------------
68| 29.6k| }
69| |
70| 112k| IGRAPH_FINALLY_CLEAN(1);
71| 112k| return IGRAPH_SUCCESS;
72| 112k|}
igraph_trie_destroy:
102| 112k|void igraph_trie_destroy(igraph_trie_t *t) {
103| 112k| if (t->storekeys) {
------------------
| Branch (103:9): [True: 29.6k, False: 82.9k]
------------------
104| 29.6k| igraph_strvector_destroy(&t->keys);
105| 29.6k| }
106| 112k| igraph_i_trie_destroy_node(&t->node);
107| 112k|}
igraph_trie_get:
298| 3.38M|igraph_error_t igraph_trie_get(igraph_trie_t *t, const char *key, igraph_int_t *id) {
299| 3.38M| assert(key != NULL);
------------------
| Branch (299:5): [True: 0, False: 3.38M]
| Branch (299:5): [True: 3.38M, False: 0]
------------------
300| |
301| 3.38M| if (*key == '\0') {
------------------
| Branch (301:9): [True: 4, False: 3.38M]
------------------
302| 4| IGRAPH_ERROR("Keys in a trie cannot be empty.", IGRAPH_EINVAL);
------------------
| | 426| 4| do { \
| | 427| 4| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 4| return igraph_errno ; \
| | 429| 4| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
303| 4| }
304| |
305| 3.38M| if (!t->storekeys) {
------------------
| Branch (305:9): [True: 910k, False: 2.46M]
------------------
306| 910k| IGRAPH_CHECK(igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id));
------------------
| | 656| 910k| do { \
| | 657| 910k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 910k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 910k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 910k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 910k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 910k]
| | ------------------
------------------
307| 910k| if (*id > t->maxvalue) {
------------------
| Branch (307:13): [True: 54.6k, False: 855k]
------------------
308| 54.6k| t->maxvalue = *id;
309| 54.6k| }
310| 2.46M| } else {
311| 2.46M| igraph_error_t ret;
312| |
313| 2.46M| IGRAPH_FINALLY_ENTER();
314| | /* Add it to the string vector first, we can undo this later */
315| 2.46M| ret = igraph_strvector_push_back(&t->keys, key);
316| 2.46M| if (ret != IGRAPH_SUCCESS) {
------------------
| Branch (316:13): [True: 0, False: 2.46M]
------------------
317| 0| IGRAPH_FINALLY_EXIT();
318| 0| IGRAPH_ERROR("Cannot get element from trie.", ret);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
319| 0| }
320| 2.46M| ret = igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id);
321| 2.46M| if (ret != IGRAPH_SUCCESS) {
------------------
| Branch (321:13): [True: 0, False: 2.46M]
------------------
322| 0| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */
323| 0| IGRAPH_FINALLY_EXIT();
324| 0| IGRAPH_ERROR("Cannot get element from trie.", ret);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
325| 0| }
326| |
327| | /* everything is fine */
328| 2.46M| if (*id > t->maxvalue) {
------------------
| Branch (328:13): [True: 119k, False: 2.35M]
------------------
329| 119k| t->maxvalue = *id;
330| 2.35M| } else {
331| 2.35M| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */
332| 2.35M| }
333| 2.46M| IGRAPH_FINALLY_EXIT();
334| 2.46M| }
335| |
336| 3.38M| return IGRAPH_SUCCESS;
337| 3.38M|}
igraph_trie_get_len:
357| 1.04M| igraph_int_t *id) {
358| |
359| 1.04M| char *tmp = strndup(key, length);
360| 1.04M| IGRAPH_CHECK_OOM(tmp, "Cannot get from trie.");
------------------
| | 709| 1.04M| do { \
| | 710| 1.04M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.04M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.04M]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 1.04M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.04M]
| | ------------------
------------------
361| 1.04M| IGRAPH_FINALLY(igraph_free, tmp);
------------------
| | 603| 1.04M| do { \
| | 604| 1.04M| /* the following branch makes the compiler check the compatibility of \
| | 605| 1.04M| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 1.04M| * incorrect destructor function with the pointer */ \
| | 607| 1.04M| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 1.04M]
| | ------------------
| | 608| 1.04M| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 1.04M| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 1.04M]
| | ------------------
------------------
362| 1.04M| IGRAPH_CHECK(igraph_trie_get(t, tmp, id));
------------------
| | 656| 1.04M| do { \
| | 657| 1.04M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.04M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.04M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.04M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.04M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.04M]
| | ------------------
------------------
363| 1.04M| IGRAPH_FREE(tmp);
------------------
| | 36| 1.04M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
364| 1.04M| IGRAPH_FINALLY_CLEAN(1);
365| |
366| 1.04M| return IGRAPH_SUCCESS;
367| 1.04M|}
igraph_trie_check:
383| 1.12M|igraph_error_t igraph_trie_check(igraph_trie_t *t, const char *key, igraph_int_t *id) {
384| 1.12M| IGRAPH_CHECK(igraph_i_trie_get_node(&t->node, key, -1, id));
------------------
| | 656| 1.12M| do { \
| | 657| 1.12M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.12M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.12M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.12M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.12M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.12M]
| | ------------------
------------------
385| 1.12M| return IGRAPH_SUCCESS;
386| 1.12M|}
igraph_trie_size:
413| 468k|igraph_int_t igraph_trie_size(igraph_trie_t *t) {
414| 468k| return t->maxvalue + 1;
415| 468k|}
igraph_i_trie_borrow_keys:
432| 9.72k|const igraph_strvector_t* igraph_i_trie_borrow_keys(igraph_trie_t *t) {
433| 9.72k| return &t->keys;
434| 9.72k|}
trie.c:igraph_i_trie_init_node:
41| 112k|static igraph_error_t igraph_i_trie_init_node(igraph_trie_node_t *t) {
42| 112k| IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0);
------------------
| | 62| 112k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 112k| do { \
| | | | 657| 112k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 112k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 112k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 112k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 112k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 112k]
| | | | ------------------
| | ------------------
| | 63| 112k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 112k| do { \
| | | | 604| 112k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 112k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 112k| * incorrect destructor function with the pointer */ \
| | | | 607| 112k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 112k]
| | | | ------------------
| | | | 608| 112k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 112k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 112k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 112k]
| | ------------------
------------------
43| 112k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0);
------------------
| | 46| 112k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 112k| do { \
| | | | 657| 112k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 112k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 112k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 112k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 112k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 112k]
| | | | ------------------
| | ------------------
| | 47| 112k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 112k| do { \
| | | | 604| 112k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 112k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 112k| * incorrect destructor function with the pointer */ \
| | | | 607| 112k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 112k]
| | | | ------------------
| | | | 608| 112k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 112k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 112k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 112k]
| | ------------------
------------------
44| 112k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->values, 0);
------------------
| | 119| 112k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 112k| do { \
| | | | 657| 112k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 112k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 112k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 112k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 112k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 112k]
| | | | ------------------
| | ------------------
| | 120| 112k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 112k| do { \
| | | | 604| 112k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 112k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 112k| * incorrect destructor function with the pointer */ \
| | | | 607| 112k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 112k]
| | | | ------------------
| | | | 608| 112k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 112k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 112k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 112k]
| | ------------------
------------------
45| 112k| IGRAPH_FINALLY_CLEAN(3);
46| 112k| return IGRAPH_SUCCESS;
47| 112k|}
trie.c:igraph_i_trie_destroy_node:
91| 112k|static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) {
92| | igraph_i_trie_destroy_node_helper(t, false);
93| 112k|}
trie.c:igraph_i_trie_destroy_node_helper:
74| 138k|static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) {
75| 138k| igraph_strvector_destroy(&t->strs);
76| 138k| igraph_int_t children_size = igraph_vector_ptr_size(&t->children);
77| 325k| for (igraph_int_t i = 0; i < children_size; i++) {
------------------
| Branch (77:30): [True: 187k, False: 138k]
------------------
78| 187k| igraph_trie_node_t *child = VECTOR(t->children)[i];
------------------
| | 60| 187k|#define VECTOR(v) ((v).stor_begin)
------------------
79| 187k| if (child != NULL) {
------------------
| Branch (79:13): [True: 25.4k, False: 161k]
------------------
80| 25.4k| igraph_i_trie_destroy_node_helper(child, true);
81| 25.4k| }
82| 187k| }
83| 138k| igraph_vector_ptr_destroy(&t->children);
84| 138k| igraph_vector_int_destroy(&t->values);
85| 138k| if (sfree) {
------------------
| Branch (85:9): [True: 25.4k, False: 112k]
------------------
86| | IGRAPH_FREE(t);
------------------
| | 36| 25.4k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
87| 25.4k| }
88| 138k|}
trie.c:igraph_i_trie_get_node:
129| 6.69M|) {
130| 6.69M| assert(key != NULL);
------------------
| Branch (130:5): [True: 0, False: 6.69M]
| Branch (130:5): [True: 6.69M, False: 0]
------------------
131| |
132| | /* If newvalue is negative, we don't add the node if nonexistent, only check
133| | * for its existence */
134| 6.69M| igraph_bool_t add = (newvalue >= 0);
135| |
136| 6.69M| igraph_int_t strs_size = igraph_strvector_size(&t->strs);
137| 17.0M| for (igraph_int_t i = 0; i < strs_size; i++) {
------------------
| Branch (137:30): [True: 16.8M, False: 160k]
------------------
138| 16.8M| size_t diff;
139| 16.8M| const char *str = igraph_strvector_get(&t->strs, i);
140| 16.8M| diff = igraph_i_strdiff(str, key);
141| |
142| 16.8M| if (diff == 0) {
------------------
| Branch (142:13): [True: 10.3M, False: 6.53M]
------------------
143| |
144| | /* ------------------------------------ */
145| | /* No match, next */
146| |
147| 10.3M| } else if (str[diff] == '\0' && key[diff] == '\0') {
------------------
| Branch (147:20): [True: 6.51M, False: 18.5k]
| Branch (147:41): [True: 4.31M, False: 2.20M]
------------------
148| |
149| | /* ------------------------------------ */
150| | /* They are exactly the same */
151| 4.31M| if (VECTOR(t->values)[i] != -1) {
------------------
| | 60| 4.31M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (151:17): [True: 4.31M, False: 754]
------------------
152| 4.31M| *id = VECTOR(t->values)[i];
------------------
| | 60| 4.31M|#define VECTOR(v) ((v).stor_begin)
------------------
153| 4.31M| return IGRAPH_SUCCESS;
154| 4.31M| } else {
155| 754| VECTOR(t->values)[i] = newvalue;
------------------
| | 60| 754|#define VECTOR(v) ((v).stor_begin)
------------------
156| 754| *id = newvalue;
157| 754| return IGRAPH_SUCCESS;
158| 754| }
159| |
160| 4.31M| } else if (str[diff] == '\0') {
------------------
| Branch (160:20): [True: 2.20M, False: 18.5k]
------------------
161| |
162| | /* ------------------------------------ */
163| | /* str is prefix of key, follow its link if there is one */
164| 2.20M| igraph_trie_node_t *node = VECTOR(t->children)[i];
------------------
| | 60| 2.20M|#define VECTOR(v) ((v).stor_begin)
------------------
165| 2.20M| if (node != NULL) {
------------------
| Branch (165:17): [True: 2.19M, False: 9.81k]
------------------
166| 2.19M| return igraph_i_trie_get_node(node, key + diff, newvalue, id);
167| 2.19M| } else if (add) {
------------------
| Branch (167:24): [True: 9.39k, False: 423]
------------------
168| 9.39k| igraph_trie_node_t *new_node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 9.39k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 18.7k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 9.39k, Folded]
| | | | ------------------
| | ------------------
------------------
169| 9.39k| IGRAPH_CHECK_OOM(new_node, "Cannot add to trie.");
------------------
| | 709| 9.39k| do { \
| | 710| 9.39k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 9.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.39k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 9.39k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 9.39k]
| | ------------------
------------------
170| 9.39k| IGRAPH_FINALLY(igraph_free, new_node);
------------------
| | 603| 9.39k| do { \
| | 604| 9.39k| /* the following branch makes the compiler check the compatibility of \
| | 605| 9.39k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 9.39k| * incorrect destructor function with the pointer */ \
| | 607| 9.39k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 9.39k]
| | ------------------
| | 608| 9.39k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 9.39k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 9.39k]
| | ------------------
------------------
171| |
172| 9.39k| IGRAPH_STRVECTOR_INIT_FINALLY(&new_node->strs, 1);
------------------
| | 62| 9.39k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 9.39k| do { \
| | | | 657| 9.39k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.39k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 9.39k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.39k]
| | | | ------------------
| | ------------------
| | 63| 9.39k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 9.39k| do { \
| | | | 604| 9.39k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.39k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.39k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.39k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.39k]
| | | | ------------------
| | | | 608| 9.39k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.39k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.39k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 9.39k]
| | ------------------
------------------
173| 9.39k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&new_node->children, 1);
------------------
| | 46| 9.39k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 9.39k| do { \
| | | | 657| 9.39k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.39k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 9.39k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.39k]
| | | | ------------------
| | ------------------
| | 47| 9.39k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 9.39k| do { \
| | | | 604| 9.39k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.39k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.39k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.39k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.39k]
| | | | ------------------
| | | | 608| 9.39k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.39k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.39k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 9.39k]
| | ------------------
------------------
174| 9.39k| IGRAPH_VECTOR_INT_INIT_FINALLY(&new_node->values, 1);
------------------
| | 119| 9.39k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 9.39k| do { \
| | | | 657| 9.39k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.39k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 9.39k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.39k]
| | | | ------------------
| | ------------------
| | 120| 9.39k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 9.39k| do { \
| | | | 604| 9.39k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.39k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.39k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.39k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.39k]
| | | | ------------------
| | | | 608| 9.39k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.39k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.39k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 9.39k]
| | ------------------
------------------
175| 9.39k| IGRAPH_CHECK(igraph_strvector_set(&new_node->strs, 0, key + diff));
------------------
| | 656| 9.39k| do { \
| | 657| 9.39k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 9.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 9.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.39k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 9.39k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 9.39k]
| | ------------------
------------------
176| 9.39k| IGRAPH_FINALLY_CLEAN(4);
177| |
178| 9.39k| VECTOR(new_node->children)[0] = 0;
------------------
| | 60| 9.39k|#define VECTOR(v) ((v).stor_begin)
------------------
179| 9.39k| VECTOR(new_node->values)[0] = newvalue;
------------------
| | 60| 9.39k|#define VECTOR(v) ((v).stor_begin)
------------------
180| |
181| 9.39k| VECTOR(t->children)[i] = new_node;
------------------
| | 60| 9.39k|#define VECTOR(v) ((v).stor_begin)
------------------
182| |
183| 9.39k| *id = newvalue;
184| 9.39k| return IGRAPH_SUCCESS;
185| 9.39k| } else {
186| 423| *id = -1;
187| 423| return IGRAPH_SUCCESS;
188| 423| }
189| |
190| 2.20M| } else if (key[diff] == '\0' && add) {
------------------
| Branch (190:20): [True: 2.14k, False: 16.3k]
| Branch (190:41): [True: 1.75k, False: 388]
------------------
191| |
192| | /* ------------------------------------ */
193| | /* key is prefix of str, the node has to be cut */
194| 1.75k| char *str2;
195| |
196| 1.75k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 1.75k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 3.51k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 1.75k, Folded]
| | | | ------------------
| | ------------------
------------------
197| 1.75k| IGRAPH_CHECK_OOM(node, "Cannot add to trie.");
------------------
| | 709| 1.75k| do { \
| | 710| 1.75k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.75k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.75k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 1.75k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.75k]
| | ------------------
------------------
198| 1.75k| IGRAPH_FINALLY(igraph_free, node);
------------------
| | 603| 1.75k| do { \
| | 604| 1.75k| /* the following branch makes the compiler check the compatibility of \
| | 605| 1.75k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 1.75k| * incorrect destructor function with the pointer */ \
| | 607| 1.75k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 1.75k]
| | ------------------
| | 608| 1.75k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 1.75k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 1.75k]
| | ------------------
------------------
199| |
200| 1.75k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1);
------------------
| | 62| 1.75k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 1.75k| do { \
| | | | 657| 1.75k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 1.75k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 1.75k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 1.75k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 1.75k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 1.75k]
| | | | ------------------
| | ------------------
| | 63| 1.75k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 1.75k| do { \
| | | | 604| 1.75k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.75k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.75k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.75k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.75k]
| | | | ------------------
| | | | 608| 1.75k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.75k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.75k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 1.75k]
| | ------------------
------------------
201| 1.75k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1);
------------------
| | 46| 1.75k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 1.75k| do { \
| | | | 657| 1.75k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 1.75k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 1.75k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 1.75k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 1.75k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 1.75k]
| | | | ------------------
| | ------------------
| | 47| 1.75k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 1.75k| do { \
| | | | 604| 1.75k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.75k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.75k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.75k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.75k]
| | | | ------------------
| | | | 608| 1.75k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.75k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.75k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 1.75k]
| | ------------------
------------------
202| 1.75k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1);
------------------
| | 119| 1.75k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 1.75k| do { \
| | | | 657| 1.75k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 1.75k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 1.75k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 1.75k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 1.75k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 1.75k]
| | | | ------------------
| | ------------------
| | 120| 1.75k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 1.75k| do { \
| | | | 604| 1.75k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.75k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.75k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.75k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.75k]
| | | | ------------------
| | | | 608| 1.75k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.75k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.75k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 1.75k]
| | ------------------
------------------
203| 1.75k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff));
------------------
| | 656| 1.75k| do { \
| | 657| 1.75k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.75k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.75k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.75k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.75k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.75k]
| | ------------------
------------------
204| |
205| 1.75k| VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 1.75k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 1.75k|#define VECTOR(v) ((v).stor_begin)
------------------
206| 1.75k| VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 1.75k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 1.75k|#define VECTOR(v) ((v).stor_begin)
------------------
207| |
208| 1.75k| str2 = strdup(str);
209| 1.75k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie.");
------------------
| | 709| 1.75k| do { \
| | 710| 1.75k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.75k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.75k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 1.75k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.75k]
| | ------------------
------------------
210| 1.75k| IGRAPH_FINALLY(igraph_free, str2);
------------------
| | 603| 1.75k| do { \
| | 604| 1.75k| /* the following branch makes the compiler check the compatibility of \
| | 605| 1.75k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 1.75k| * incorrect destructor function with the pointer */ \
| | 607| 1.75k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 1.75k]
| | ------------------
| | 608| 1.75k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 1.75k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 1.75k]
| | ------------------
------------------
211| 1.75k| str2[diff] = '\0';
212| |
213| 1.75k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2));
------------------
| | 656| 1.75k| do { \
| | 657| 1.75k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.75k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.75k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.75k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.75k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.75k]
| | ------------------
------------------
214| |
215| 1.75k| IGRAPH_FREE(str2);
------------------
| | 36| 1.75k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
216| 1.75k| IGRAPH_FINALLY_CLEAN(5);
217| |
218| 1.75k| VECTOR(t->values)[i] = newvalue;
------------------
| | 60| 1.75k|#define VECTOR(v) ((v).stor_begin)
------------------
219| 1.75k| VECTOR(t->children)[i] = node;
------------------
| | 60| 1.75k|#define VECTOR(v) ((v).stor_begin)
------------------
220| |
221| 1.75k| *id = newvalue;
222| 1.75k| return IGRAPH_SUCCESS;
223| |
224| 16.7k| } else if (add) {
------------------
| Branch (224:20): [True: 14.2k, False: 2.48k]
------------------
225| |
226| | /* ------------------------------------ */
227| | /* the first diff characters match */
228| 14.2k| char *str2;
229| |
230| 14.2k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 14.2k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 28.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 14.2k, Folded]
| | | | ------------------
| | ------------------
------------------
231| 14.2k| IGRAPH_CHECK_OOM(node, "Cannot add to trie.");
------------------
| | 709| 14.2k| do { \
| | 710| 14.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 14.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 14.2k]
| | ------------------
------------------
232| 14.2k| IGRAPH_FINALLY(igraph_free, node);
------------------
| | 603| 14.2k| do { \
| | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | 607| 14.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 14.2k]
| | ------------------
| | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 14.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 14.2k]
| | ------------------
------------------
233| |
234| 14.2k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2);
------------------
| | 62| 14.2k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 14.2k| do { \
| | | | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | 63| 14.2k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 14.2k| do { \
| | | | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 14.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 14.2k]
| | | | ------------------
| | | | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 14.2k]
| | ------------------
------------------
235| 14.2k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2);
------------------
| | 46| 14.2k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 14.2k| do { \
| | | | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | 47| 14.2k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 14.2k| do { \
| | | | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 14.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 14.2k]
| | | | ------------------
| | | | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 14.2k]
| | ------------------
------------------
236| 14.2k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 2);
------------------
| | 119| 14.2k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 14.2k| do { \
| | | | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | 120| 14.2k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 14.2k| do { \
| | | | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 14.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 14.2k]
| | | | ------------------
| | | | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 14.2k]
| | ------------------
------------------
237| 14.2k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
238| 14.2k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
239| 14.2k| VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
240| 14.2k| VECTOR(node->children)[1] = 0;
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
241| 14.2k| VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
242| 14.2k| VECTOR(node->values)[1] = newvalue;
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
243| |
244| 14.2k| str2 = strdup(str);
245| 14.2k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie.");
------------------
| | 709| 14.2k| do { \
| | 710| 14.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 14.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 14.2k]
| | ------------------
------------------
246| |
247| 14.2k| str2[diff] = '\0';
248| 14.2k| IGRAPH_FINALLY(igraph_free, str2);
------------------
| | 603| 14.2k| do { \
| | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | 607| 14.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 14.2k]
| | ------------------
| | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 14.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 14.2k]
| | ------------------
------------------
249| |
250| 14.2k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
251| |
252| 14.2k| IGRAPH_FREE(str2);
------------------
| | 36| 14.2k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
253| 14.2k| IGRAPH_FINALLY_CLEAN(5);
254| |
255| 14.2k| VECTOR(t->values)[i] = -1;
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
256| 14.2k| VECTOR(t->children)[i] = node;
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
257| |
258| 14.2k| *id = newvalue;
259| 14.2k| return IGRAPH_SUCCESS;
260| 14.2k| } else {
261| |
262| | /* ------------------------------------------------- */
263| | /* No match, but we requested not to add the new key */
264| 2.48k| *id = -1;
265| 2.48k| return IGRAPH_SUCCESS;
266| 2.48k| }
267| 16.8M| }
268| |
269| | /* ------------------------------------ */
270| | /* Nothing matches */
271| |
272| 160k| if (add) {
------------------
| Branch (272:9): [True: 147k, False: 12.9k]
------------------
273| | /* Memory saving at the cost of performance may be possible by using the pattern
274| | * CHECK(reserve(vec, size(vec) + 1));
275| | * push_back(vec, value);
276| | * This was the original pattern used before igraph 0.10. */
277| 147k| IGRAPH_CHECK(igraph_strvector_push_back(&t->strs, key));
------------------
| | 656| 147k| do { \
| | 657| 147k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 147k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 147k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 147k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 147k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 147k]
| | ------------------
------------------
278| 147k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t->children, NULL));
------------------
| | 656| 147k| do { \
| | 657| 147k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 147k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 147k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 147k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 147k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 147k]
| | ------------------
------------------
279| 147k| IGRAPH_CHECK(igraph_vector_int_push_back(&t->values, newvalue));
------------------
| | 656| 147k| do { \
| | 657| 147k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 147k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 147k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 147k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 147k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 147k]
| | ------------------
------------------
280| 147k| *id = newvalue;
281| 147k| } else {
282| 12.9k| *id = -1;
283| 12.9k| }
284| |
285| 160k| return IGRAPH_SUCCESS;
286| 160k|}
trie.c:igraph_i_strdiff:
111| 16.8M|static size_t igraph_i_strdiff(const char *str, const char *key) {
112| 16.8M| size_t diff = 0;
113| 315M| while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) {
------------------
| Branch (113:12): [True: 311M, False: 4.31M]
| Branch (113:33): [True: 308M, False: 2.20M]
| Branch (113:54): [True: 298M, False: 10.3M]
------------------
114| 298M| diff++;
115| 298M| }
116| 16.8M| return diff;
117| 16.8M|}
igraph_attribute_record_list_init:
109| 85.9k|igraph_error_t FUNCTION(init)(TYPE *v, igraph_int_t size) {
110| 85.9k| igraph_int_t alloc_size = size > 0 ? size : 1;
------------------
| Branch (110:31): [True: 6.77k, False: 79.2k]
------------------
111| 85.9k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 85.9k| do { \
| | 925| 85.9k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 85.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.9k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 85.9k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 85.9k]
| | ------------------
------------------
112| 85.9k| v->stor_begin = IGRAPH_CALLOC(alloc_size, ITEM_TYPE);
------------------
| | 33| 85.9k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 171k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 85.9k, False: 0]
| | | | | Branch (31:24): [True: 85.9k, False: 0]
| | | | | Branch (31:66): [True: 85.9k, False: 0]
| | | | ------------------
| | ------------------
------------------
113| 85.9k| if (v->stor_begin == 0) {
------------------
| Branch (113:9): [True: 0, False: 85.9k]
------------------
114| 0| IGRAPH_ERROR("Cannot initialize list.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
115| 0| }
116| 85.9k| v->stor_end = v->stor_begin + alloc_size;
117| 85.9k| v->end = v->stor_begin + size;
118| |
119| 85.9k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin, v->end));
------------------
| | 656| 85.9k| do { \
| | 657| 85.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 85.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 85.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 85.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 85.9k]
| | ------------------
------------------
120| |
121| 85.9k| return IGRAPH_SUCCESS;
122| 85.9k|}
igraph_attribute_record_list_init_copy:
141| 9.98k|igraph_error_t FUNCTION(init_copy)(TYPE* to, const TYPE* from) {
142| 9.98k| igraph_int_t i, size = FUNCTION(size)(from);
------------------
| | 161| 9.98k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 9.98k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
143| |
144| 9.98k| IGRAPH_CHECK(FUNCTION(init)(to, 0));
------------------
| | 656| 9.98k| do { \
| | 657| 9.98k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 9.98k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 9.98k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.98k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 9.98k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 9.98k]
| | ------------------
------------------
145| 9.98k| IGRAPH_FINALLY(FUNCTION(destroy), to);
------------------
| | 603| 9.98k| do { \
| | 604| 9.98k| /* the following branch makes the compiler check the compatibility of \
| | 605| 9.98k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 9.98k| * incorrect destructor function with the pointer */ \
| | 607| 9.98k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 9.98k]
| | ------------------
| | 608| 9.98k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 9.98k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 9.98k]
| | ------------------
------------------
146| |
147| 12.3k| for (i = 0; i < size; i++) {
------------------
| Branch (147:17): [True: 2.39k, False: 9.98k]
------------------
148| 2.39k| IGRAPH_CHECK(FUNCTION(push_back_copy)(to, FUNCTION(get_ptr)(from, i)));
------------------
| | 656| 2.39k| do { \
| | 657| 2.39k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.39k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.39k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.39k]
| | ------------------
------------------
149| 2.39k| }
150| |
151| 9.98k| IGRAPH_FINALLY_CLEAN(1);
152| |
153| 9.98k| return IGRAPH_SUCCESS;
154| 9.98k|}
igraph_attribute_record_list_destroy:
176| 85.9k|void FUNCTION(destroy)(TYPE *v) {
177| 85.9k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 85.9k| do { \
| | 925| 85.9k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 85.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.9k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 85.9k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 85.9k]
| | ------------------
------------------
178| |
179| 85.9k| if (v->stor_begin != 0) {
------------------
| Branch (179:9): [True: 85.9k, False: 0]
------------------
180| 85.9k| FUNCTION(clear)(v);
------------------
| | 161| 85.9k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 85.9k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
181| 85.9k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 85.9k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
182| | v->stor_begin = NULL;
183| 85.9k| }
184| 85.9k|}
igraph_attribute_record_list_capacity:
203| 13.5k|igraph_int_t FUNCTION(capacity)(const TYPE *v) {
204| 13.5k| return v->stor_end - v->stor_begin;
205| 13.5k|}
igraph_attribute_record_list_reserve:
233| 13.5k|igraph_error_t FUNCTION(reserve)(TYPE *v, igraph_int_t capacity) {
234| 13.5k| igraph_int_t current_capacity;
235| 13.5k| ITEM_TYPE *tmp;
------------------
| | 61| 13.5k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 13.5k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
236| |
237| 13.5k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 13.5k| do { \
| | 925| 13.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 13.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 13.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 13.5k]
| | ------------------
------------------
238| 13.5k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 13.5k| do { \
| | 925| 13.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 13.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 13.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 13.5k]
| | ------------------
------------------
239| 13.5k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 13.5k| do { \
| | 925| 13.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 13.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 13.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 13.5k]
| | ------------------
------------------
240| |
241| 13.5k| current_capacity = FUNCTION(capacity)(v);
------------------
| | 161| 13.5k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 13.5k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
242| |
243| 13.5k| if (capacity <= current_capacity) {
------------------
| Branch (243:9): [True: 0, False: 13.5k]
------------------
244| 0| return IGRAPH_SUCCESS;
245| 0| }
246| |
247| 13.5k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, ITEM_TYPE);
------------------
| | 35| 13.5k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 27.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 13.5k, False: 0]
| | | | | Branch (31:24): [True: 13.5k, False: 0]
| | | | | Branch (31:66): [True: 13.5k, False: 0]
| | | | ------------------
| | ------------------
------------------
248| 13.5k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for list.");
------------------
| | 709| 13.5k| do { \
| | 710| 13.5k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 13.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.5k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 13.5k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 13.5k]
| | ------------------
------------------
249| |
250| 13.5k| v->end = tmp + (v->end - v->stor_begin);
251| 13.5k| v->stor_begin = tmp;
252| 13.5k| v->stor_end = v->stor_begin + capacity;
253| |
254| 13.5k| return IGRAPH_SUCCESS;
255| 13.5k|}
igraph_attribute_record_list_size:
287| 2.02M|igraph_int_t FUNCTION(size)(const TYPE *v) {
288| 2.02M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 2.02M| do { \
| | 925| 2.02M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.02M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.02M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.02M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.02M]
| | ------------------
------------------
289| 2.02M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 2.02M| do { \
| | 925| 2.02M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.02M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.02M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.02M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.02M]
| | ------------------
------------------
290| 2.02M| return v->end - v->stor_begin;
291| 2.02M|}
igraph_attribute_record_list_clear:
357| 85.9k|void FUNCTION(clear)(TYPE *v) {
358| 85.9k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 85.9k| do { \
| | 925| 85.9k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 85.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.9k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 85.9k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 85.9k]
| | ------------------
------------------
359| 85.9k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 85.9k| do { \
| | 925| 85.9k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 85.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.9k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 85.9k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 85.9k]
| | ------------------
------------------
360| 85.9k| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin, v->end);
------------------
| | 162| 85.9k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 85.9k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
361| 85.9k| v->end = v->stor_begin;
362| 85.9k|}
igraph_attribute_record_list_get_ptr:
377| 5.77M|ITEM_TYPE *FUNCTION(get_ptr)(const TYPE *v, igraph_int_t pos) {
378| 5.77M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 5.77M| do { \
| | 925| 5.77M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 5.77M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.77M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 5.77M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 5.77M]
| | ------------------
------------------
379| 5.77M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 5.77M| do { \
| | 925| 5.77M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 5.77M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.77M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 5.77M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 5.77M]
| | ------------------
------------------
380| 5.77M| return v->stor_begin + pos;
381| 5.77M|}
igraph_attribute_record_list_push_back:
587| 22.4k|igraph_error_t FUNCTION(push_back)(TYPE *v, ITEM_TYPE *e) {
588| 22.4k| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v));
------------------
| | 656| 22.4k| do { \
| | 657| 22.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 22.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.4k]
| | ------------------
------------------
589| 22.4k| *(v->end) = *e;
590| 22.4k| v->end += 1;
591| 22.4k| return IGRAPH_SUCCESS;
592| 22.4k|}
igraph_attribute_record_list_push_back_copy:
612| 2.39k|igraph_error_t FUNCTION(push_back_copy)(TYPE *v, const ITEM_TYPE *e) {
613| 2.39k| ITEM_TYPE copy;
------------------
| | 61| 2.39k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 2.39k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
614| 2.39k| IGRAPH_CHECK(INTERNAL_FUNCTION(copy_item)(©, e));
------------------
| | 656| 2.39k| do { \
| | 657| 2.39k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.39k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.39k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.39k]
| | ------------------
------------------
615| 2.39k| IGRAPH_FINALLY(INTERNAL_FUNCTION(destroy_item), ©);
------------------
| | 603| 2.39k| do { \
| | 604| 2.39k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.39k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.39k| * incorrect destructor function with the pointer */ \
| | 607| 2.39k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.39k]
| | ------------------
| | 608| 2.39k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.39k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.39k]
| | ------------------
------------------
616| 2.39k| IGRAPH_CHECK(FUNCTION(push_back)(v, ©));
------------------
| | 656| 2.39k| do { \
| | 657| 2.39k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.39k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.39k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.39k]
| | ------------------
------------------
617| 2.39k| IGRAPH_FINALLY_CLEAN(1);
618| 2.39k| return IGRAPH_SUCCESS;
619| 2.39k|}
igraph_attribute_record_list_push_back_new:
640| 32.8k|igraph_error_t FUNCTION(push_back_new)(TYPE *v, ITEM_TYPE** e) {
641| 32.8k| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v));
------------------
| | 656| 32.8k| do { \
| | 657| 32.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 32.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.8k]
| | ------------------
------------------
642| 32.8k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_item)(v, v->end));
------------------
| | 656| 32.8k| do { \
| | 657| 32.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 32.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.8k]
| | ------------------
------------------
643| 32.8k| if (e) {
------------------
| Branch (643:9): [True: 32.8k, False: 0]
------------------
644| 32.8k| *e = v->end;
645| 32.8k| }
646| 32.8k| v->end += 1;
647| 32.8k| return IGRAPH_SUCCESS;
648| 32.8k|}
attributes.c:igraph_i_attribute_record_list_init_slice:
1068| 85.9k|static igraph_error_t INTERNAL_FUNCTION(init_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) {
1069| 85.9k| ITEM_TYPE *current;
------------------
| | 61| 85.9k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 85.9k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
1070| 85.9k| igraph_error_t retval;
1071| |
1072| 92.7k| for (current = start; current < end; current++) {
------------------
| Branch (1072:27): [True: 6.77k, False: 85.9k]
------------------
1073| 6.77k| retval = INTERNAL_FUNCTION(init_item)(list, current);
------------------
| | 162| 6.77k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 6.77k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1074| 6.77k| if (retval) {
------------------
| Branch (1074:13): [True: 0, False: 6.77k]
------------------
1075| 0| INTERNAL_FUNCTION(destroy_slice)(list, start, current);
------------------
| | 162| 0| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 0|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1076| 0| IGRAPH_CHECK(retval);
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
1077| 0| }
1078| 6.77k| }
1079| |
1080| 85.9k| return IGRAPH_SUCCESS;
1081| 85.9k|}
attributes.c:igraph_i_attribute_record_list_destroy_slice:
1083| 85.9k|static void INTERNAL_FUNCTION(destroy_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) {
1084| 85.9k| IGRAPH_UNUSED(list);
------------------
| | 30| 85.9k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1085| 148k| for (; start < end; start++) {
------------------
| Branch (1085:12): [True: 62.0k, False: 85.9k]
------------------
1086| 62.0k| INTERNAL_FUNCTION(destroy_item)(start);
------------------
| | 162| 62.0k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 62.0k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1087| 62.0k| }
1088| 85.9k|}
attributes.c:igraph_i_attribute_record_list_expand_if_full:
1094| 55.2k|static igraph_error_t INTERNAL_FUNCTION(expand_if_full)(TYPE *v) {
1095| 55.2k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 55.2k| do { \
| | 925| 55.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 55.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 55.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 55.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 55.2k]
| | ------------------
------------------
1096| 55.2k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 55.2k| do { \
| | 925| 55.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 55.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 55.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 55.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 55.2k]
| | ------------------
------------------
1097| |
1098| 55.2k| if (v->stor_end == v->end) {
------------------
| Branch (1098:9): [True: 13.5k, False: 41.6k]
------------------
1099| 13.5k| igraph_int_t old_size = FUNCTION(size)(v);
------------------
| | 161| 13.5k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 13.5k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1100| 13.5k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 13.5k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 13.5k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (1100:33): [True: 13.5k, False: 0]
------------------
1101| 13.5k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 13.5k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (1101:13): [True: 0, False: 13.5k]
------------------
1102| 0| IGRAPH_ERROR("Cannot add new item to list, already at maximum size.", IGRAPH_EOVERFLOW);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1103| 0| }
1104| 13.5k| if (new_size == 0) {
------------------
| Branch (1104:13): [True: 0, False: 13.5k]
------------------
1105| 0| new_size = 1;
1106| 0| }
1107| 13.5k| IGRAPH_CHECK(FUNCTION(reserve)(v, new_size));
------------------
| | 656| 13.5k| do { \
| | 657| 13.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.5k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 13.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.5k]
| | ------------------
------------------
1108| 13.5k| }
1109| |
1110| 55.2k| return IGRAPH_SUCCESS;
1111| 55.2k|}
igraph_vector_int_pair_order:
119| 32.8k| igraph_vector_int_t* res, igraph_int_t nodes) {
120| 32.8k| igraph_int_t edges = igraph_vector_int_size(v);
121| 32.8k| igraph_vector_int_t ptr;
122| 32.8k| igraph_vector_int_t rad;
123| 32.8k| igraph_int_t i, j;
124| |
125| 32.8k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 32.8k| do { \
| | 925| 32.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 32.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 32.8k]
| | ------------------
------------------
126| 32.8k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 32.8k| do { \
| | 925| 32.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 32.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 32.8k]
| | ------------------
------------------
127| |
128| 32.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1);
------------------
| | 119| 32.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 32.8k| do { \
| | | | 657| 32.8k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 32.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 32.8k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 32.8k]
| | | | ------------------
| | ------------------
| | 120| 32.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 32.8k| do { \
| | | | 604| 32.8k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 32.8k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 32.8k| * incorrect destructor function with the pointer */ \
| | | | 607| 32.8k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 32.8k]
| | | | ------------------
| | | | 608| 32.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 32.8k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 32.8k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 32.8k]
| | ------------------
------------------
129| 32.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges);
------------------
| | 119| 32.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 32.8k| do { \
| | | | 657| 32.8k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 32.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 32.8k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 32.8k]
| | | | ------------------
| | ------------------
| | 120| 32.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 32.8k| do { \
| | | | 604| 32.8k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 32.8k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 32.8k| * incorrect destructor function with the pointer */ \
| | | | 607| 32.8k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 32.8k]
| | | | ------------------
| | | | 608| 32.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 32.8k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 32.8k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 32.8k]
| | ------------------
------------------
130| 32.8k| IGRAPH_CHECK(igraph_vector_int_resize(res, edges));
------------------
| | 656| 32.8k| do { \
| | 657| 32.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 32.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.8k]
| | ------------------
------------------
131| |
132| 3.47M| for (i = 0; i < edges; i++) {
------------------
| Branch (132:17): [True: 3.44M, False: 32.8k]
------------------
133| 3.44M| igraph_int_t radix = VECTOR(*v2)[i];
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
134| 3.44M| if (VECTOR(ptr)[radix] != 0) {
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (134:13): [True: 3.27M, False: 162k]
------------------
135| 3.27M| VECTOR(rad)[i] = VECTOR(ptr)[radix];
------------------
| | 60| 3.27M|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(rad)[i] = VECTOR(ptr)[radix];
------------------
| | 60| 3.27M|#define VECTOR(v) ((v).stor_begin)
------------------
136| 3.27M| }
137| 3.44M| VECTOR(ptr)[radix] = i + 1;
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
138| 3.44M| }
139| |
140| 32.8k| j = 0;
141| 369k| for (i = 0; i < nodes + 1; i++) {
------------------
| Branch (141:17): [True: 336k, False: 32.8k]
------------------
142| 336k| if (VECTOR(ptr)[i] != 0) {
------------------
| | 60| 336k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (142:13): [True: 162k, False: 174k]
------------------
143| 162k| igraph_int_t next = VECTOR(ptr)[i] - 1;
------------------
| | 60| 162k|#define VECTOR(v) ((v).stor_begin)
------------------
144| 162k| VECTOR(*res)[j++] = next;
------------------
| | 60| 162k|#define VECTOR(v) ((v).stor_begin)
------------------
145| 3.44M| while (VECTOR(rad)[next] != 0) {
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (145:20): [True: 3.27M, False: 162k]
------------------
146| 3.27M| next = VECTOR(rad)[next] - 1;
------------------
| | 60| 3.27M|#define VECTOR(v) ((v).stor_begin)
------------------
147| 3.27M| VECTOR(*res)[j++] = next;
------------------
| | 60| 3.27M|#define VECTOR(v) ((v).stor_begin)
------------------
148| 3.27M| }
149| 162k| }
150| 336k| }
151| |
152| 32.8k| igraph_vector_int_null(&ptr);
153| 32.8k| igraph_vector_int_null(&rad);
154| |
155| 3.47M| for (i = 0; i < edges; i++) {
------------------
| Branch (155:17): [True: 3.44M, False: 32.8k]
------------------
156| 3.44M| igraph_int_t edge = VECTOR(*res)[edges - i - 1];
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
157| 3.44M| igraph_int_t radix = VECTOR(*v)[edge];
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
158| 3.44M| if (VECTOR(ptr)[radix] != 0) {
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (158:13): [True: 3.27M, False: 162k]
------------------
159| 3.27M| VECTOR(rad)[edge] = VECTOR(ptr)[radix];
------------------
| | 60| 3.27M|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(rad)[edge] = VECTOR(ptr)[radix];
------------------
| | 60| 3.27M|#define VECTOR(v) ((v).stor_begin)
------------------
160| 3.27M| }
161| 3.44M| VECTOR(ptr)[radix] = edge + 1;
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
162| 3.44M| }
163| |
164| 32.8k| j = 0;
165| 369k| for (i = 0; i < nodes + 1; i++) {
------------------
| Branch (165:17): [True: 336k, False: 32.8k]
------------------
166| 336k| if (VECTOR(ptr)[i] != 0) {
------------------
| | 60| 336k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (166:13): [True: 162k, False: 174k]
------------------
167| 162k| igraph_int_t next = VECTOR(ptr)[i] - 1;
------------------
| | 60| 162k|#define VECTOR(v) ((v).stor_begin)
------------------
168| 162k| VECTOR(*res)[j++] = next;
------------------
| | 60| 162k|#define VECTOR(v) ((v).stor_begin)
------------------
169| 3.44M| while (VECTOR(rad)[next] != 0) {
------------------
| | 60| 3.44M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (169:20): [True: 3.27M, False: 162k]
------------------
170| 3.27M| next = VECTOR(rad)[next] - 1;
------------------
| | 60| 3.27M|#define VECTOR(v) ((v).stor_begin)
------------------
171| 3.27M| VECTOR(*res)[j++] = next;
------------------
| | 60| 3.27M|#define VECTOR(v) ((v).stor_begin)
------------------
172| 3.27M| }
173| 162k| }
174| 336k| }
175| |
176| 32.8k| igraph_vector_int_destroy(&ptr);
177| 32.8k| igraph_vector_int_destroy(&rad);
178| 32.8k| IGRAPH_FINALLY_CLEAN(2);
179| |
180| 32.8k| return IGRAPH_SUCCESS;
181| 32.8k|}
igraph_vector_init:
134| 32.2k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 32.2k| igraph_int_t alloc_size;
136| 32.2k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 32.2k| do { \
| | 925| 32.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 32.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 32.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 32.2k]
| | ------------------
------------------
137| 32.2k| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 10.6k, False: 21.6k]
------------------
138| |
139| | /* When this function fails, it should leave stor_begin set to NULL,
140| | * so that vector_destroy() is still safe to call on the vector.
141| | * This simplifies freeing partially initialized data structures,
142| | * such as adjacency lists, when an error occurs mid-initialization. */
143| 32.2k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 32.2k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 64.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 32.2k, False: 0]
| | | | | Branch (31:24): [True: 32.2k, False: 0]
| | | | | Branch (31:66): [True: 32.2k, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 32.2k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 32.2k| do { \
| | 710| 32.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 32.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 32.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 32.2k]
| | ------------------
------------------
145| 32.2k| v->stor_end = v->stor_begin + alloc_size;
146| 32.2k| v->end = v->stor_begin + size;
147| |
148| 32.2k| return IGRAPH_SUCCESS;
149| 32.2k|}
igraph_vector_destroy:
408| 32.2k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 32.2k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 32.2k| do { \
| | 925| 32.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 32.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 32.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 32.2k]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 32.2k| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 32.2k, False: 0]
------------------
413| 32.2k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 32.2k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 32.2k| }
416| 32.2k|}
igraph_vector_capacity:
436| 439k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 439k| return v->stor_end - v->stor_begin;
438| 439k|}
igraph_vector_reserve:
468| 433k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 433k| igraph_int_t current_capacity;
470| 433k| BASE *tmp;
------------------
| | 29| 433k| #define BASE igraph_real_t
------------------
471| |
472| 433k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 433k| do { \
| | 925| 433k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 433k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 433k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 433k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 433k]
| | ------------------
------------------
473| 433k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 433k| do { \
| | 925| 433k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 433k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 433k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 433k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 433k]
| | ------------------
------------------
474| 433k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 433k| do { \
| | 925| 433k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 433k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 433k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 433k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 433k]
| | ------------------
------------------
475| |
476| 433k| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 170| 433k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 433k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 433k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
477| |
478| 433k| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 406k, False: 27.3k]
------------------
479| 406k| return IGRAPH_SUCCESS;
480| 406k| }
481| |
482| 27.3k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 27.3k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 54.7k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 27.3k, False: 0]
| | | | | Branch (31:24): [True: 27.3k, False: 0]
| | | | | Branch (31:66): [True: 27.3k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 27.3k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 27.3k| do { \
| | 710| 27.3k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 27.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.3k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 27.3k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 27.3k]
| | ------------------
------------------
484| |
485| 27.3k| v->end = tmp + (v->end - v->stor_begin);
486| 27.3k| v->stor_begin = tmp;
487| 27.3k| v->stor_end = v->stor_begin + capacity;
488| |
489| 27.3k| return IGRAPH_SUCCESS;
490| 27.3k|}
igraph_vector_size:
522| 464k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 464k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 464k| do { \
| | 925| 464k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 464k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 464k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 464k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 464k]
| | ------------------
------------------
524| 464k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 464k| do { \
| | 925| 464k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 464k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 464k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 464k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 464k]
| | ------------------
------------------
525| 464k| return v->end - v->stor_begin;
526| 464k|}
igraph_vector_clear:
542| 404k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 404k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 404k| do { \
| | 925| 404k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 404k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 404k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 404k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 404k]
| | ------------------
------------------
544| 404k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 404k| do { \
| | 925| 404k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 404k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 404k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 404k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 404k]
| | ------------------
------------------
545| 404k| v->end = v->stor_begin;
546| 404k|}
igraph_vector_push_back:
573| 685k|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 685k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 685k| do { \
| | 925| 685k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 685k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 685k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 685k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 685k]
| | ------------------
------------------
575| 685k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 685k| do { \
| | 925| 685k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 685k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 685k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 685k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 685k]
| | ------------------
------------------
576| |
577| 685k| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 13.3k, False: 672k]
------------------
578| | /* full, allocate more storage */
579| 13.3k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 170| 13.3k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 13.3k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 13.3k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
580| 13.3k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 13.3k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 13.3k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 13.3k, False: 0]
------------------
581| 13.3k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 13.3k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 13.3k]
------------------
582| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
583| 0| }
584| 13.3k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 13.3k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 13.3k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 13.3k| do { \
| | 657| 13.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.3k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 13.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.3k]
| | ------------------
------------------
588| 13.3k| }
589| |
590| 685k| *(v->end) = e;
591| 685k| v->end += 1;
592| |
593| 685k| return IGRAPH_SUCCESS;
594| 685k|}
igraph_vector_sort:
958| 37|void FUNCTION(igraph_vector, sort)(TYPE(igraph_vector) *v) {
959| 37| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 37| do { \
| | 925| 37| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 37| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 37]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 37| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 37]
| | ------------------
------------------
960| 37| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 37| do { \
| | 925| 37| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 37| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 37]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 37| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 37]
| | ------------------
------------------
961| 37| igraph_qsort(v->stor_begin, FUNCTION(igraph_vector, size)(v),
------------------
| | 170| 37| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 37|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 37|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
962| 37| sizeof(BASE), FUNCTION(igraph_vector, sort_cmp));
------------------
| | 170| 37| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 37|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 37|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
963| 37|}
igraph_vector_resize:
1264| 415k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 415k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 415k| do { \
| | 925| 415k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 415k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 415k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 415k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 415k]
| | ------------------
------------------
1266| 415k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 415k| do { \
| | 925| 415k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 415k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 415k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 415k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 415k]
| | ------------------
------------------
1267| 415k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 415k| do { \
| | 657| 415k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 415k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 415k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 415k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 415k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 415k]
| | ------------------
------------------
1268| 415k| v->end = v->stor_begin + new_size;
1269| 415k| return IGRAPH_SUCCESS;
1270| 415k|}
igraph_vector_init_copy:
1538| 37|) {
1539| 37| igraph_int_t from_size;
1540| |
1541| 37| IGRAPH_ASSERT(from != NULL);
------------------
| | 924| 37| do { \
| | 925| 37| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 37| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 37]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 37| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 37]
| | ------------------
------------------
1542| 37| IGRAPH_ASSERT(from->stor_begin != NULL);
------------------
| | 924| 37| do { \
| | 925| 37| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 37| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 37]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 37| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 37]
| | ------------------
------------------
1543| |
1544| 37| from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 37| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 37|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 37|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
1545| 37| IGRAPH_CHECK(FUNCTION(igraph_vector, init)(to, from_size));
------------------
| | 656| 37| do { \
| | 657| 37| igraph_error_t igraph_i_ret = (expr); \
| | 658| 37| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 37| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 37]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 37| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 37]
| | ------------------
------------------
1546| |
1547| 37| memcpy(to->stor_begin, from->stor_begin, from_size * sizeof(BASE));
1548| |
1549| 37| return IGRAPH_SUCCESS;
1550| 37|}
igraph_vector_append:
2427| 6.08k| const TYPE(igraph_vector) *from) {
2428| 6.08k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 6.08k| do { \
| | 925| 6.08k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.08k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.08k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.08k]
| | ------------------
------------------
2429| 6.08k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 6.08k| do { \
| | 925| 6.08k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.08k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.08k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.08k]
| | ------------------
------------------
2430| |
2431| 6.08k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 170| 6.08k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 6.08k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 6.08k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2432| 6.08k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 6.08k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 6.08k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 6.08k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2433| 6.08k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 170| 6.08k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 6.08k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 6.08k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2434| 6.08k| igraph_int_t new_to_size;
2435| |
2436| 6.08k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 6.08k| do { \
| | 48| 6.08k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 6.08k| igraph_int_t _safe_sum; \
| | 50| 6.08k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 6.08k]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 6.08k| *(res) = _safe_sum; \
| | 54| 6.08k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 6.08k]
| | ------------------
------------------
2437| |
2438| 6.08k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 4.58k, False: 1.50k]
------------------
2439| 4.58k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 4.58k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 4.58k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 4.58k, False: 0]
------------------
2440| 4.58k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 3.52k, False: 1.05k]
------------------
2441| 3.52k| new_to_capacity = new_to_size;
2442| 3.52k| }
2443| 4.58k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 656| 4.58k| do { \
| | 657| 4.58k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.58k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.58k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.58k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.58k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.58k]
| | ------------------
------------------
2444| 4.58k| }
2445| |
2446| 6.08k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 6.08k| sizeof(BASE) * from_size);
2448| 6.08k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 6.08k| return IGRAPH_SUCCESS;
2451| 6.08k|}
igraph_vector_update:
2524| 373| const TYPE(igraph_vector) *from) {
2525| 373| igraph_int_t n = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 373| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 373|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 373|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2526| 373| IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, n));
------------------
| | 656| 373| do { \
| | 657| 373| igraph_error_t igraph_i_ret = (expr); \
| | 658| 373| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 373| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 373]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 373| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 373]
| | ------------------
------------------
2527| 373| memcpy(to->stor_begin, from->stor_begin, sizeof(BASE)*n);
2528| 373| return IGRAPH_SUCCESS;
2529| 373|}
igraph_vector_swap:
2541| 331|void FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) {
2542| |
2543| 331| TYPE(igraph_vector) tmp;
------------------
| | 171| 331| #define TYPE(a) CONCAT2(a,t)
| | ------------------
| | | | 20| 331|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 331|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2544| |
2545| 331| tmp = *v1;
2546| 331| *v1 = *v2;
2547| 331| *v2 = tmp;
2548| 331|}
igraph_vector_char_init:
134| 1.52M|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 1.52M| igraph_int_t alloc_size;
136| 1.52M| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 1.52M| do { \
| | 925| 1.52M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.52M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.52M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.52M]
| | ------------------
------------------
137| 1.52M| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 1.49M, False: 29.8k]
------------------
138| |
139| | /* When this function fails, it should leave stor_begin set to NULL,
140| | * so that vector_destroy() is still safe to call on the vector.
141| | * This simplifies freeing partially initialized data structures,
142| | * such as adjacency lists, when an error occurs mid-initialization. */
143| 1.52M| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 1.52M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 3.05M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 1.52M, False: 0]
| | | | | Branch (31:24): [True: 1.52M, False: 0]
| | | | | Branch (31:66): [True: 1.52M, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 1.52M| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 1.52M| do { \
| | 710| 1.52M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.52M]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 1.52M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.52M]
| | ------------------
------------------
145| 1.52M| v->stor_end = v->stor_begin + alloc_size;
146| 1.52M| v->end = v->stor_begin + size;
147| |
148| 1.52M| return IGRAPH_SUCCESS;
149| 1.52M|}
igraph_vector_char_view:
182| 39.1M| const BASE *data, igraph_int_t length) {
183| |
184| 39.1M| static const BASE dummy = ZERO;
------------------
| | 48| 39.1M| #define ZERO 0
------------------
185| 39.1M| TYPE(igraph_vector) v;
------------------
| | 179| 39.1M| #define TYPE(a) CONCAT3(a,SHORT,t)
| | ------------------
| | | | 22| 39.1M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 39.1M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
186| |
187| | /* When the length is zero, we allow 'data' to be NULL.
188| | * An igraph_vector_t may never contain a NULL pointer,
189| | * thus we use a pointer to a dummy variable in this case. */
190| 39.1M| if (length == 0) {
------------------
| Branch (190:9): [True: 194, False: 39.1M]
------------------
191| 194| data = &dummy;
192| 39.1M| } else {
193| 39.1M| IGRAPH_ASSERT(data != NULL);
------------------
| | 924| 39.1M| do { \
| | 925| 39.1M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 39.1M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39.1M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 39.1M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 39.1M]
| | ------------------
------------------
194| 39.1M| }
195| |
196| 39.1M| v.stor_begin = (BASE*)data;
197| 39.1M| v.stor_end = (BASE*)data + length;
198| 39.1M| v.end = v.stor_end;
199| 39.1M| return v;
200| 39.1M|}
igraph_vector_char_destroy:
408| 1.52M|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 1.52M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.52M| do { \
| | 925| 1.52M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.52M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.52M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.52M]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 1.52M| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 1.52M, False: 0]
------------------
413| 1.52M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 1.52M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 1.52M| }
416| 1.52M|}
igraph_vector_char_capacity:
436| 40.8M|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 40.8M| return v->stor_end - v->stor_begin;
438| 40.8M|}
igraph_vector_char_reserve:
468| 1.65M|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 1.65M| igraph_int_t current_capacity;
470| 1.65M| BASE *tmp;
------------------
| | 43| 1.65M| #define BASE char
------------------
471| |
472| 1.65M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.65M| do { \
| | 925| 1.65M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.65M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.65M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.65M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.65M]
| | ------------------
------------------
473| 1.65M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.65M| do { \
| | 925| 1.65M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.65M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.65M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.65M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.65M]
| | ------------------
------------------
474| 1.65M| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 1.65M| do { \
| | 925| 1.65M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.65M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.65M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.65M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.65M]
| | ------------------
------------------
475| |
476| 1.65M| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 178| 1.65M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 1.65M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 1.65M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
477| |
478| 1.65M| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 1.00M, False: 650k]
------------------
479| 1.00M| return IGRAPH_SUCCESS;
480| 1.00M| }
481| |
482| 650k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 650k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 1.30M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 650k, False: 0]
| | | | | Branch (31:24): [True: 650k, False: 0]
| | | | | Branch (31:66): [True: 650k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 650k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 650k| do { \
| | 710| 650k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 650k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 650k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 650k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 650k]
| | ------------------
------------------
484| |
485| 650k| v->end = tmp + (v->end - v->stor_begin);
486| 650k| v->stor_begin = tmp;
487| 650k| v->stor_end = v->stor_begin + capacity;
488| |
489| 650k| return IGRAPH_SUCCESS;
490| 650k|}
igraph_vector_char_size:
522| 79.3M|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 79.3M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 79.3M| do { \
| | 925| 79.3M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 79.3M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 79.3M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 79.3M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 79.3M]
| | ------------------
------------------
524| 79.3M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 79.3M| do { \
| | 925| 79.3M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 79.3M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 79.3M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 79.3M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 79.3M]
| | ------------------
------------------
525| 79.3M| return v->end - v->stor_begin;
526| 79.3M|}
igraph_vector_char_clear:
542| 837k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 837k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 837k| do { \
| | 925| 837k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 837k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 837k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 837k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 837k]
| | ------------------
------------------
544| 837k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 837k| do { \
| | 925| 837k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 837k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 837k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 837k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 837k]
| | ------------------
------------------
545| 837k| v->end = v->stor_begin;
546| 837k|}
igraph_vector_char_push_back:
573| 1.41M|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 1.41M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.41M| do { \
| | 925| 1.41M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.41M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.41M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.41M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.41M]
| | ------------------
------------------
575| 1.41M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.41M| do { \
| | 925| 1.41M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.41M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.41M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.41M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.41M]
| | ------------------
------------------
576| |
577| 1.41M| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 629k, False: 787k]
------------------
578| | /* full, allocate more storage */
579| 629k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 178| 629k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 629k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 629k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
580| 629k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 629k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 629k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 629k, False: 0]
------------------
581| 629k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 629k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 629k]
------------------
582| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
583| 0| }
584| 629k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 629k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 629k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 629k| do { \
| | 657| 629k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 629k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 629k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 629k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 629k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 629k]
| | ------------------
------------------
588| 629k| }
589| |
590| 1.41M| *(v->end) = e;
591| 1.41M| v->end += 1;
592| |
593| 1.41M| return IGRAPH_SUCCESS;
594| 1.41M|}
igraph_vector_char_resize:
1264| 1.01M|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 1.01M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.01M| do { \
| | 925| 1.01M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.01M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.01M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.01M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.01M]
| | ------------------
------------------
1266| 1.01M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.01M| do { \
| | 925| 1.01M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.01M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.01M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.01M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.01M]
| | ------------------
------------------
1267| 1.01M| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 1.01M| do { \
| | 657| 1.01M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.01M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.01M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.01M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.01M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.01M]
| | ------------------
------------------
1268| 1.01M| v->end = v->stor_begin + new_size;
1269| 1.01M| return IGRAPH_SUCCESS;
1270| 1.01M|}
igraph_vector_char_append:
2427| 39.1M| const TYPE(igraph_vector) *from) {
2428| 39.1M| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 39.1M| do { \
| | 925| 39.1M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 39.1M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39.1M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 39.1M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 39.1M]
| | ------------------
------------------
2429| 39.1M| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 39.1M| do { \
| | 925| 39.1M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 39.1M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39.1M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 39.1M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 39.1M]
| | ------------------
------------------
2430| |
2431| 39.1M| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 178| 39.1M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 39.1M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 39.1M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2432| 39.1M| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 178| 39.1M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 39.1M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 39.1M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2433| 39.1M| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 178| 39.1M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 39.1M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 39.1M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2434| 39.1M| igraph_int_t new_to_size;
2435| |
2436| 39.1M| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 39.1M| do { \
| | 48| 39.1M| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 39.1M| igraph_int_t _safe_sum; \
| | 50| 39.1M| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 39.1M]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 39.1M| *(res) = _safe_sum; \
| | 54| 39.1M| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 39.1M]
| | ------------------
------------------
2437| |
2438| 39.1M| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 10.8k, False: 39.1M]
------------------
2439| 10.8k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 10.8k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 10.8k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 10.8k, False: 0]
------------------
2440| 10.8k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 3.42k, False: 7.40k]
------------------
2441| 3.42k| new_to_capacity = new_to_size;
2442| 3.42k| }
2443| 10.8k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 656| 10.8k| do { \
| | 657| 10.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 10.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.8k]
| | ------------------
------------------
2444| 10.8k| }
2445| |
2446| 39.1M| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 39.1M| sizeof(BASE) * from_size);
2448| 39.1M| to->end = to->stor_begin + new_to_size;
2449| |
2450| 39.1M| return IGRAPH_SUCCESS;
2451| 39.1M|}
igraph_vector_bool_init:
134| 15.0k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 15.0k| igraph_int_t alloc_size;
136| 15.0k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 15.0k| do { \
| | 925| 15.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 15.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 15.0k]
| | ------------------
------------------
137| 15.0k| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 6.76k, False: 8.25k]
------------------
138| |
139| | /* When this function fails, it should leave stor_begin set to NULL,
140| | * so that vector_destroy() is still safe to call on the vector.
141| | * This simplifies freeing partially initialized data structures,
142| | * such as adjacency lists, when an error occurs mid-initialization. */
143| 15.0k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 15.0k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 30.0k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 15.0k, False: 0]
| | | | | Branch (31:24): [True: 15.0k, False: 0]
| | | | | Branch (31:66): [True: 15.0k, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 15.0k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 15.0k| do { \
| | 710| 15.0k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.0k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 15.0k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 15.0k]
| | ------------------
------------------
145| 15.0k| v->stor_end = v->stor_begin + alloc_size;
146| 15.0k| v->end = v->stor_begin + size;
147| |
148| 15.0k| return IGRAPH_SUCCESS;
149| 15.0k|}
igraph_vector_bool_destroy:
408| 15.0k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 15.0k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 15.0k| do { \
| | 925| 15.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 15.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 15.0k]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 15.0k| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 15.0k, False: 0]
------------------
413| 15.0k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 15.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 15.0k| }
416| 15.0k|}
igraph_vector_bool_capacity:
436| 51.4k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 51.4k| return v->stor_end - v->stor_begin;
438| 51.4k|}
igraph_vector_bool_reserve:
468| 49.3k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 49.3k| igraph_int_t current_capacity;
470| 49.3k| BASE *tmp;
------------------
| | 53| 49.3k| #define BASE igraph_bool_t
------------------
471| |
472| 49.3k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 49.3k| do { \
| | 925| 49.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 49.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 49.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 49.3k]
| | ------------------
------------------
473| 49.3k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 49.3k| do { \
| | 925| 49.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 49.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 49.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 49.3k]
| | ------------------
------------------
474| 49.3k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 49.3k| do { \
| | 925| 49.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 49.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 49.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 49.3k]
| | ------------------
------------------
475| |
476| 49.3k| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 175| 49.3k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 49.3k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
477| |
478| 49.3k| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 37.1k, False: 12.2k]
------------------
479| 37.1k| return IGRAPH_SUCCESS;
480| 37.1k| }
481| |
482| 12.2k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 12.2k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 24.4k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 12.2k, False: 0]
| | | | | Branch (31:24): [True: 12.2k, False: 0]
| | | | | Branch (31:66): [True: 12.2k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 12.2k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 12.2k| do { \
| | 710| 12.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 12.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 12.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 12.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 12.2k]
| | ------------------
------------------
484| |
485| 12.2k| v->end = tmp + (v->end - v->stor_begin);
486| 12.2k| v->stor_begin = tmp;
487| 12.2k| v->stor_end = v->stor_begin + capacity;
488| |
489| 12.2k| return IGRAPH_SUCCESS;
490| 12.2k|}
igraph_vector_bool_size:
522| 69.7k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 69.7k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 69.7k| do { \
| | 925| 69.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 69.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 69.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 69.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 69.7k]
| | ------------------
------------------
524| 69.7k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 69.7k| do { \
| | 925| 69.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 69.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 69.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 69.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 69.7k]
| | ------------------
------------------
525| 69.7k| return v->end - v->stor_begin;
526| 69.7k|}
igraph_vector_bool_clear:
542| 34.6k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 34.6k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 34.6k| do { \
| | 925| 34.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 34.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 34.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 34.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 34.6k]
| | ------------------
------------------
544| 34.6k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 34.6k| do { \
| | 925| 34.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 34.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 34.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 34.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 34.6k]
| | ------------------
------------------
545| 34.6k| v->end = v->stor_begin;
546| 34.6k|}
igraph_vector_bool_push_back:
573| 417|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 417| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 417| do { \
| | 925| 417| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417]
| | ------------------
------------------
575| 417| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 417| do { \
| | 925| 417| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417]
| | ------------------
------------------
576| |
577| 417| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 0, False: 417]
------------------
578| | /* full, allocate more storage */
579| 0| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 175| 0| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 0|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
580| 0| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 0|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 0|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 0, False: 0]
------------------
581| 0| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 0|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 0]
------------------
582| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
583| 0| }
584| 0| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 0]
------------------
585| 0| new_size = 1;
586| 0| }
587| 0| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
588| 0| }
589| |
590| 417| *(v->end) = e;
591| 417| v->end += 1;
592| |
593| 417| return IGRAPH_SUCCESS;
594| 417|}
igraph_vector_bool_resize:
1264| 48.0k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 48.0k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 48.0k| do { \
| | 925| 48.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 48.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 48.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 48.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 48.0k]
| | ------------------
------------------
1266| 48.0k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 48.0k| do { \
| | 925| 48.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 48.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 48.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 48.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 48.0k]
| | ------------------
------------------
1267| 48.0k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 48.0k| do { \
| | 657| 48.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 48.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 48.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 48.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 48.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 48.0k]
| | ------------------
------------------
1268| 48.0k| v->end = v->stor_begin + new_size;
1269| 48.0k| return IGRAPH_SUCCESS;
1270| 48.0k|}
igraph_vector_bool_append:
2427| 2.11k| const TYPE(igraph_vector) *from) {
2428| 2.11k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 2.11k| do { \
| | 925| 2.11k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.11k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.11k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.11k]
| | ------------------
------------------
2429| 2.11k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 2.11k| do { \
| | 925| 2.11k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.11k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.11k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.11k]
| | ------------------
------------------
2430| |
2431| 2.11k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 175| 2.11k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 2.11k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2432| 2.11k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 175| 2.11k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 2.11k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2433| 2.11k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 175| 2.11k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 2.11k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2434| 2.11k| igraph_int_t new_to_size;
2435| |
2436| 2.11k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 2.11k| do { \
| | 48| 2.11k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 2.11k| igraph_int_t _safe_sum; \
| | 50| 2.11k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 2.11k]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 2.11k| *(res) = _safe_sum; \
| | 54| 2.11k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 2.11k]
| | ------------------
------------------
2437| |
2438| 2.11k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 1.34k, False: 769]
------------------
2439| 1.34k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 1.34k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 1.34k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 1.34k, False: 0]
------------------
2440| 1.34k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 1.13k, False: 209]
------------------
2441| 1.13k| new_to_capacity = new_to_size;
2442| 1.13k| }
2443| 1.34k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 656| 1.34k| do { \
| | 657| 1.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.34k]
| | ------------------
------------------
2444| 1.34k| }
2445| |
2446| 2.11k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 2.11k| sizeof(BASE) * from_size);
2448| 2.11k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 2.11k| return IGRAPH_SUCCESS;
2451| 2.11k|}
igraph_vector_bool_update:
2524| 274| const TYPE(igraph_vector) *from) {
2525| 274| igraph_int_t n = FUNCTION(igraph_vector, size)(from);
------------------
| | 175| 274| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 274|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2526| 274| IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, n));
------------------
| | 656| 274| do { \
| | 657| 274| igraph_error_t igraph_i_ret = (expr); \
| | 658| 274| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 274| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 274]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 274| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 274]
| | ------------------
------------------
2527| 274| memcpy(to->stor_begin, from->stor_begin, sizeof(BASE)*n);
2528| 274| return IGRAPH_SUCCESS;
2529| 274|}
igraph_vector_int_init:
134| 1.95M|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 1.95M| igraph_int_t alloc_size;
136| 1.95M| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 1.95M| do { \
| | 925| 1.95M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.95M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.95M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.95M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.95M]
| | ------------------
------------------
137| 1.95M| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 1.61M, False: 340k]
------------------
138| |
139| | /* When this function fails, it should leave stor_begin set to NULL,
140| | * so that vector_destroy() is still safe to call on the vector.
141| | * This simplifies freeing partially initialized data structures,
142| | * such as adjacency lists, when an error occurs mid-initialization. */
143| 1.95M| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 1.95M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 3.91M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 1.95M, False: 0]
| | | | | Branch (31:24): [True: 1.95M, False: 0]
| | | | | Branch (31:66): [True: 1.95M, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 1.95M| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 1.95M| do { \
| | 710| 1.95M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.95M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.95M]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 1.95M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.95M]
| | ------------------
------------------
145| 1.95M| v->stor_end = v->stor_begin + alloc_size;
146| 1.95M| v->end = v->stor_begin + size;
147| |
148| 1.95M| return IGRAPH_SUCCESS;
149| 1.95M|}
igraph_vector_int_destroy:
408| 1.95M|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 1.95M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.95M| do { \
| | 925| 1.95M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.95M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.95M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.95M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.95M]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 1.95M| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 1.95M, False: 0]
------------------
413| 1.95M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 1.95M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 1.95M| }
416| 1.95M|}
igraph_vector_int_capacity:
436| 1.15M|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 1.15M| return v->stor_end - v->stor_begin;
438| 1.15M|}
igraph_vector_int_reserve:
468| 1.15M|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 1.15M| igraph_int_t current_capacity;
470| 1.15M| BASE *tmp;
------------------
| | 66| 1.15M| #define BASE igraph_int_t
------------------
471| |
472| 1.15M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.15M| do { \
| | 925| 1.15M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.15M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.15M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.15M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.15M]
| | ------------------
------------------
473| 1.15M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.15M| do { \
| | 925| 1.15M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.15M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.15M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.15M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.15M]
| | ------------------
------------------
474| 1.15M| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 1.15M| do { \
| | 925| 1.15M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.15M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.15M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.15M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.15M]
| | ------------------
------------------
475| |
476| 1.15M| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 178| 1.15M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 1.15M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 1.15M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
477| |
478| 1.15M| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 331k, False: 819k]
------------------
479| 331k| return IGRAPH_SUCCESS;
480| 331k| }
481| |
482| 819k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 819k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 1.63M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 819k, False: 0]
| | | | | Branch (31:24): [True: 819k, False: 0]
| | | | | Branch (31:66): [True: 819k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 819k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 819k| do { \
| | 710| 819k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 819k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 819k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 819k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 819k]
| | ------------------
------------------
484| |
485| 819k| v->end = tmp + (v->end - v->stor_begin);
486| 819k| v->stor_begin = tmp;
487| 819k| v->stor_end = v->stor_begin + capacity;
488| |
489| 819k| return IGRAPH_SUCCESS;
490| 819k|}
igraph_vector_int_empty:
503| 431k|igraph_bool_t FUNCTION(igraph_vector, empty)(const TYPE(igraph_vector) *v) {
504| 431k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 431k| do { \
| | 925| 431k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 431k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 431k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 431k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 431k]
| | ------------------
------------------
505| 431k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 431k| do { \
| | 925| 431k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 431k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 431k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 431k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 431k]
| | ------------------
------------------
506| 431k| return v->stor_begin == v->end;
507| 431k|}
igraph_vector_int_size:
522| 7.24M|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 7.24M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 7.24M| do { \
| | 925| 7.24M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 7.24M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.24M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 7.24M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 7.24M]
| | ------------------
------------------
524| 7.24M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 7.24M| do { \
| | 925| 7.24M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 7.24M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.24M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 7.24M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 7.24M]
| | ------------------
------------------
525| 7.24M| return v->end - v->stor_begin;
526| 7.24M|}
igraph_vector_int_push_back:
573| 8.34M|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 8.34M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 8.34M| do { \
| | 925| 8.34M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.34M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.34M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.34M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.34M]
| | ------------------
------------------
575| 8.34M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 8.34M| do { \
| | 925| 8.34M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.34M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.34M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.34M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.34M]
| | ------------------
------------------
576| |
577| 8.34M| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 724k, False: 7.62M]
------------------
578| | /* full, allocate more storage */
579| 724k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 178| 724k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 724k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 724k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
580| 724k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 724k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 724k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 724k, False: 0]
------------------
581| 724k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 724k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 724k]
------------------
582| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
583| 0| }
584| 724k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 724k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 724k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 724k| do { \
| | 657| 724k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 724k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 724k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 724k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 724k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 724k]
| | ------------------
------------------
588| 724k| }
589| |
590| 8.34M| *(v->end) = e;
591| 8.34M| v->end += 1;
592| |
593| 8.34M| return IGRAPH_SUCCESS;
594| 8.34M|}
igraph_vector_int_null:
725| 77.8k|void FUNCTION(igraph_vector, null)(TYPE(igraph_vector) *v) {
726| 77.8k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 77.8k| do { \
| | 925| 77.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 77.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 77.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 77.8k]
| | ------------------
------------------
727| 77.8k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 77.8k| do { \
| | 925| 77.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 77.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 77.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 77.8k]
| | ------------------
------------------
728| 77.8k| if (FUNCTION(igraph_vector, size)(v) > 0) {
------------------
| | 178| 77.8k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 77.8k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 77.8k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
| Branch (728:9): [True: 67.3k, False: 10.5k]
------------------
729| 67.3k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v));
------------------
| | 178| 67.3k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 67.3k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 67.3k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
730| 67.3k| }
731| 77.8k|}
igraph_vector_int_pop_back:
838| 426k|BASE FUNCTION(igraph_vector, pop_back)(TYPE(igraph_vector) *v) {
839| 426k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 426k| do { \
| | 925| 426k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 426k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 426k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 426k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 426k]
| | ------------------
------------------
840| 426k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 426k| do { \
| | 925| 426k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 426k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 426k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 426k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 426k]
| | ------------------
------------------
841| 426k| IGRAPH_ASSERT(v->end != NULL);
------------------
| | 924| 426k| do { \
| | 925| 426k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 426k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 426k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 426k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 426k]
| | ------------------
------------------
842| 426k| IGRAPH_ASSERT(v->end != v->stor_begin);
------------------
| | 924| 426k| do { \
| | 925| 426k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 426k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 426k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 426k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 426k]
| | ------------------
------------------
843| |
844| 426k| (v->end)--;
845| |
846| 426k| return *(v->end);
847| 426k|}
igraph_vector_int_resize:
1264| 298k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 298k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 298k| do { \
| | 925| 298k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 298k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 298k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 298k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 298k]
| | ------------------
------------------
1266| 298k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 298k| do { \
| | 925| 298k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 298k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 298k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 298k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 298k]
| | ------------------
------------------
1267| 298k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 298k| do { \
| | 657| 298k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 298k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 298k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 298k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 298k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 298k]
| | ------------------
------------------
1268| 298k| v->end = v->stor_begin + new_size;
1269| 298k| return IGRAPH_SUCCESS;
1270| 298k|}
igraph_vector_int_max:
1327| 2.36k|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector) *v) {
1328| 2.36k| BASE max;
------------------
| | 66| 2.36k| #define BASE igraph_int_t
------------------
1329| 2.36k| BASE *ptr;
------------------
| | 66| 2.36k| #define BASE igraph_int_t
------------------
1330| 2.36k| IGRAPH_ASSERT(!FUNCTION(igraph_vector, empty)(v));
------------------
| | 924| 2.36k| do { \
| | 925| 2.36k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.36k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.36k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.36k]
| | ------------------
------------------
1331| 2.36k| max = *(v->stor_begin);
1332| |#if defined(BASE_IGRAPH_REAL)
1333| | if (isnan(max)) { return max; }; /* Result is NaN */
1334| |#endif
1335| 2.36k| ptr = v->stor_begin + 1;
1336| 687k| while (ptr < v->end) {
------------------
| Branch (1336:12): [True: 684k, False: 2.36k]
------------------
1337| 684k| if ((*ptr) > max) {
------------------
| Branch (1337:13): [True: 23.4k, False: 661k]
------------------
1338| 23.4k| max = *ptr;
1339| 23.4k| }
1340| |#if defined(BASE_IGRAPH_REAL)
1341| | else if (isnan(*ptr))
1342| | return *ptr; /* Result is NaN */
1343| |#endif
1344| 684k| ptr++;
1345| 684k| }
1346| 2.36k| return max;
1347| 2.36k|}
igraph_vector_int_isininterval:
1832| 16.4k| BASE high) {
1833| 16.4k| BASE *ptr;
------------------
| | 66| 16.4k| #define BASE igraph_int_t
------------------
1834| 16.4k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 16.4k| do { \
| | 925| 16.4k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.4k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.4k]
| | ------------------
------------------
1835| 16.4k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 16.4k| do { \
| | 925| 16.4k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.4k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.4k]
| | ------------------
------------------
1836| 3.45M| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (1836:31): [True: 3.44M, False: 16.4k]
------------------
1837| | /* Note that the following is not equivalent to *ptr < low || *ptr > high
1838| | * when *ptr is NaN! */
1839| 3.44M| if (!(*ptr >= low && *ptr <= high)) {
------------------
| Branch (1839:15): [True: 3.44M, False: 0]
| Branch (1839:30): [True: 3.44M, False: 0]
------------------
1840| 0| return 0;
1841| 0| }
1842| 3.44M| }
1843| 16.4k| return 1;
1844| 16.4k|}
igraph_vector_int_append:
2427| 2.40k| const TYPE(igraph_vector) *from) {
2428| 2.40k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 2.40k| do { \
| | 925| 2.40k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.40k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.40k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.40k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.40k]
| | ------------------
------------------
2429| 2.40k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 2.40k| do { \
| | 925| 2.40k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.40k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.40k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.40k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.40k]
| | ------------------
------------------
2430| |
2431| 2.40k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 178| 2.40k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.40k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.40k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2432| 2.40k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 178| 2.40k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.40k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.40k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2433| 2.40k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 178| 2.40k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.40k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.40k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2434| 2.40k| igraph_int_t new_to_size;
2435| |
2436| 2.40k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 2.40k| do { \
| | 48| 2.40k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 2.40k| igraph_int_t _safe_sum; \
| | 50| 2.40k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 2.40k]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 2.40k| *(res) = _safe_sum; \
| | 54| 2.40k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 2.40k]
| | ------------------
------------------
2437| |
2438| 2.40k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 0, False: 2.40k]
------------------
2439| 0| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 0|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 0|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 0, False: 0]
------------------
2440| 0| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 0, False: 0]
------------------
2441| 0| new_to_capacity = new_to_size;
2442| 0| }
2443| 0| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
2444| 0| }
2445| |
2446| 2.40k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 2.40k| sizeof(BASE) * from_size);
2448| 2.40k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 2.40k| return IGRAPH_SUCCESS;
2451| 2.40k|}
vector.c:igraph_vector_sort_cmp:
924| 2.16k|static int FUNCTION(igraph_vector, sort_cmp)(const void *a, const void *b) {
925| 2.16k| const BASE *da = (const BASE *) a;
926| 2.16k| const BASE *db = (const BASE *) b;
927| |
928| 2.16k| return (*da > *db) - (*da < *db);
929| 2.16k|}
igraph_vector_ptr_init:
86| 3.20M|igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_int_t size) {
87| 3.20M| igraph_int_t alloc_size = size > 0 ? size : 1;
------------------
| Branch (87:31): [True: 3.01M, False: 182k]
------------------
88| 3.20M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 3.20M| do { \
| | 925| 3.20M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.20M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.20M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.20M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.20M]
| | ------------------
------------------
89| 3.20M| if (size < 0) {
------------------
| Branch (89:9): [True: 0, False: 3.20M]
------------------
90| 0| size = 0;
91| 0| }
92| 3.20M| v->stor_begin = IGRAPH_CALLOC(alloc_size, void*);
------------------
| | 33| 3.20M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 6.40M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 3.20M, False: 0]
| | | | | Branch (31:24): [True: 3.20M, False: 0]
| | | | | Branch (31:66): [True: 3.20M, False: 0]
| | | | ------------------
| | ------------------
------------------
93| 3.20M| if (v->stor_begin == 0) {
------------------
| Branch (93:9): [True: 0, False: 3.20M]
------------------
94| 0| IGRAPH_ERROR("vector ptr init failed", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
95| 0| }
96| 3.20M| v->stor_end = v->stor_begin + alloc_size;
97| 3.20M| v->end = v->stor_begin + size;
98| 3.20M| v->item_destructor = 0;
99| |
100| 3.20M| return IGRAPH_SUCCESS;
101| 3.20M|}
igraph_vector_ptr_destroy:
132| 3.20M|void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) {
133| 3.20M| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 3.20M| do { \
| | 925| 3.20M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.20M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.20M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.20M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.20M]
| | ------------------
------------------
134| 3.20M| if (v->stor_begin != 0) {
------------------
| Branch (134:9): [True: 3.20M, False: 0]
------------------
135| 3.20M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 3.20M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
136| | v->stor_begin = NULL;
137| 3.20M| }
138| 3.20M|}
igraph_vector_ptr_free_all:
170| 69.6k|void igraph_vector_ptr_free_all(igraph_vector_ptr_t* v) {
171| 69.6k| void **ptr;
172| 69.6k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 69.6k| do { \
| | 925| 69.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 69.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 69.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 69.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 69.6k]
| | ------------------
------------------
173| 69.6k| IGRAPH_ASSERT(v->stor_begin != 0);
------------------
| | 924| 69.6k| do { \
| | 925| 69.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 69.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 69.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 69.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 69.6k]
| | ------------------
------------------
174| |
175| 69.6k| igraph_i_vector_ptr_call_item_destructor_all(v);
176| 83.8k| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (176:31): [True: 14.2k, False: 69.6k]
------------------
177| | IGRAPH_FREE(*ptr);
------------------
| | 36| 14.2k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
178| 14.2k| }
179| 69.6k|}
igraph_vector_ptr_destroy_all:
199| 69.6k|void igraph_vector_ptr_destroy_all(igraph_vector_ptr_t* v) {
200| 69.6k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 69.6k| do { \
| | 925| 69.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 69.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 69.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 69.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 69.6k]
| | ------------------
------------------
201| 69.6k| IGRAPH_ASSERT(v->stor_begin != 0);
------------------
| | 924| 69.6k| do { \
| | 925| 69.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 69.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 69.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 69.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 69.6k]
| | ------------------
------------------
202| 69.6k| igraph_vector_ptr_free_all(v);
203| 69.6k| igraph_vector_ptr_set_item_destructor(v, 0);
204| 69.6k| igraph_vector_ptr_destroy(v);
205| 69.6k|}
igraph_vector_ptr_reserve:
215| 1.31M|igraph_error_t igraph_vector_ptr_reserve(igraph_vector_ptr_t* v, igraph_int_t capacity) {
216| 1.31M| igraph_int_t actual_size = igraph_vector_ptr_size(v);
217| 1.31M| void **tmp;
218| 1.31M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.31M| do { \
| | 925| 1.31M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.31M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.31M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.31M]
| | ------------------
------------------
219| 1.31M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.31M| do { \
| | 925| 1.31M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.31M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.31M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.31M]
| | ------------------
------------------
220| 1.31M| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 1.31M| do { \
| | 925| 1.31M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.31M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.31M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.31M]
| | ------------------
------------------
221| |
222| 1.31M| if (capacity <= igraph_vector_ptr_size(v)) {
------------------
| Branch (222:9): [True: 0, False: 1.31M]
------------------
223| 0| return IGRAPH_SUCCESS;
224| 0| }
225| |
226| 1.31M| tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) capacity, void*);
------------------
| | 35| 1.31M|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 2.63M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 1.31M, False: 0]
| | | | | Branch (31:24): [True: 1.31M, False: 0]
| | | | | Branch (31:66): [True: 1.31M, False: 0]
| | | | ------------------
| | ------------------
------------------
227| 1.31M| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for pointer vector.");
------------------
| | 709| 1.31M| do { \
| | 710| 1.31M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.31M]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 1.31M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.31M]
| | ------------------
------------------
228| |
229| 1.31M| v->stor_begin = tmp;
230| 1.31M| v->stor_end = v->stor_begin + capacity;
231| 1.31M| v->end = v->stor_begin + actual_size;
232| |
233| 1.31M| return IGRAPH_SUCCESS;
234| 1.31M|}
igraph_vector_ptr_size:
291| 8.78M|igraph_int_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v) {
292| 8.78M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 8.78M| do { \
| | 925| 8.78M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.78M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.78M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.78M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.78M]
| | ------------------
------------------
293| 8.78M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 8.78M| do { \
| | 925| 8.78M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.78M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.78M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.78M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.78M]
| | ------------------
------------------
294| 8.78M| return v->end - v->stor_begin;
295| 8.78M|}
igraph_vector_ptr_push_back:
360| 2.38M|igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) {
361| 2.38M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 2.38M| do { \
| | 925| 2.38M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.38M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.38M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.38M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.38M]
| | ------------------
------------------
362| 2.38M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 2.38M| do { \
| | 925| 2.38M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.38M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.38M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.38M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.38M]
| | ------------------
------------------
363| |
364| | /* full, allocate more storage */
365| 2.38M| if (v->stor_end == v->end) {
------------------
| Branch (365:9): [True: 1.31M, False: 1.06M]
------------------
366| 1.31M| igraph_int_t new_size = igraph_vector_ptr_size(v) * 2;
367| 1.31M| if (new_size == 0) {
------------------
| Branch (367:13): [True: 0, False: 1.31M]
------------------
368| 0| new_size = 1;
369| 0| }
370| 1.31M| IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size));
------------------
| | 656| 1.31M| do { \
| | 657| 1.31M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.31M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.31M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.31M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.31M]
| | ------------------
------------------
371| 1.31M| }
372| |
373| 2.38M| *(v->end) = e;
374| 2.38M| v->end += 1;
375| |
376| 2.38M| return IGRAPH_SUCCESS;
377| 2.38M|}
igraph_vector_ptr_get:
439| 17.8k|void *igraph_vector_ptr_get(const igraph_vector_ptr_t* v, igraph_int_t pos) {
440| 17.8k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 17.8k| do { \
| | 925| 17.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 17.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 17.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 17.8k]
| | ------------------
------------------
441| 17.8k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 17.8k| do { \
| | 925| 17.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 17.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 17.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 17.8k]
| | ------------------
------------------
442| 17.8k| return *(v->stor_begin + pos);
443| 17.8k|}
igraph_vector_ptr_set_item_destructor:
669| 139k| igraph_vector_ptr_t *v, igraph_finally_func_t *func) {
670| 139k| igraph_finally_func_t* result = v->item_destructor;
671| |
672| 139k| v->item_destructor = func;
673| |
674| 139k| return result;
675| 139k|}
vector_ptr.c:igraph_i_vector_ptr_call_item_destructor_all:
140| 69.6k|static void igraph_i_vector_ptr_call_item_destructor_all(igraph_vector_ptr_t* v) {
141| 69.6k| void **ptr;
142| |
143| 69.6k| if (v->item_destructor != 0) {
------------------
| Branch (143:9): [True: 69.6k, False: 0]
------------------
144| 83.8k| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (144:35): [True: 14.2k, False: 69.6k]
------------------
145| 14.2k| if (*ptr != 0) {
------------------
| Branch (145:17): [True: 14.2k, False: 0]
------------------
146| 14.2k| v->item_destructor(*ptr);
147| 14.2k| }
148| 14.2k| }
149| 69.6k| }
150| 69.6k|}
igraph_attribute_record_init:
126| 63.1k|) {
127| 63.1k| attr->name = NULL;
128| 63.1k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
129| 63.1k| attr->value.as_raw = NULL;
130| 63.1k| attr->default_value.string = NULL;
131| |
132| 63.1k| IGRAPH_CHECK(igraph_attribute_record_set_name(attr, name));
------------------
| | 656| 63.1k| do { \
| | 657| 63.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 63.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 63.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 63.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 63.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 63.1k]
| | ------------------
------------------
133| 63.1k| IGRAPH_FINALLY(igraph_free, attr->name);
------------------
| | 603| 63.1k| do { \
| | 604| 63.1k| /* the following branch makes the compiler check the compatibility of \
| | 605| 63.1k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 63.1k| * incorrect destructor function with the pointer */ \
| | 607| 63.1k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 63.1k]
| | ------------------
| | 608| 63.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 63.1k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 63.1k]
| | ------------------
------------------
134| 63.1k| IGRAPH_CHECK(igraph_attribute_record_set_type(attr, type));
------------------
| | 656| 63.1k| do { \
| | 657| 63.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 63.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 63.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 63.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 63.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 63.1k]
| | ------------------
------------------
135| 63.1k| IGRAPH_FINALLY_CLEAN(1);
136| |
137| 63.1k| return IGRAPH_SUCCESS;
138| 63.1k|}
igraph_attribute_record_init_copy:
159| 2.39k|) {
160| 2.39k| IGRAPH_CHECK(igraph_attribute_record_init(to, from->name, from->type));
------------------
| | 656| 2.39k| do { \
| | 657| 2.39k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.39k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.39k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.39k]
| | ------------------
------------------
161| |
162| 2.39k| switch (from->type) {
163| 373| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (163:9): [True: 373, False: 2.02k]
------------------
164| 373| IGRAPH_CHECK(igraph_vector_update(to->value.as_vector, from->value.as_vector));
------------------
| | 656| 373| do { \
| | 657| 373| igraph_error_t igraph_i_ret = (expr); \
| | 658| 373| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 373| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 373]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 373| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 373]
| | ------------------
------------------
165| 373| break;
166| |
167| 1.74k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (167:9): [True: 1.74k, False: 647]
------------------
168| 1.74k| IGRAPH_CHECK(igraph_strvector_update(to->value.as_strvector, from->value.as_strvector));
------------------
| | 656| 1.74k| do { \
| | 657| 1.74k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.74k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.74k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.74k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.74k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.74k]
| | ------------------
------------------
169| 1.74k| break;
170| |
171| 1.74k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (171:9): [True: 274, False: 2.12k]
------------------
172| 274| IGRAPH_CHECK(igraph_vector_bool_update(to->value.as_vector_bool, from->value.as_vector_bool));
------------------
| | 656| 274| do { \
| | 657| 274| igraph_error_t igraph_i_ret = (expr); \
| | 658| 274| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 274| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 274]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 274| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 274]
| | ------------------
------------------
173| 274| break;
174| |
175| 274| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (175:9): [True: 0, False: 2.39k]
------------------
176| 0| break;
177| |
178| 0| default:
------------------
| Branch (178:9): [True: 0, False: 2.39k]
------------------
179| 0| break;
180| 2.39k| }
181| |
182| 2.39k| return IGRAPH_SUCCESS;
183| 2.39k|}
igraph_attribute_record_destroy:
241| 66.2k|void igraph_attribute_record_destroy(igraph_attribute_record_t *attr) {
242| 66.2k| igraph_i_attribute_record_destroy_values(attr);
243| |
244| 66.2k| if (attr->name) {
------------------
| Branch (244:9): [True: 63.1k, False: 3.10k]
------------------
245| 63.1k| igraph_free(attr->name);
246| | attr->name = NULL;
247| 63.1k| }
248| 66.2k|}
igraph_attribute_record_check_type:
264| 1.60M|) {
265| 1.60M| if (type != attr->type) {
------------------
| Branch (265:9): [True: 1, False: 1.60M]
------------------
266| 1| switch (type) {
267| 0| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (267:13): [True: 0, False: 1]
------------------
268| 0| IGRAPH_ERROR("String attribute expected.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
269| 0| break;
270| 0| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (270:13): [True: 0, False: 1]
------------------
271| 0| IGRAPH_ERROR("Numeric attribute expected.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
272| 0| break;
273| 1| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (273:13): [True: 1, False: 0]
------------------
274| 1| IGRAPH_ERROR("Boolean attribute expected.", IGRAPH_EINVAL);
------------------
| | 426| 1| do { \
| | 427| 1| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 1| return igraph_errno ; \
| | 429| 1| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
275| 0| break;
276| 0| case IGRAPH_ATTRIBUTE_OBJECT:
------------------
| Branch (276:13): [True: 0, False: 1]
------------------
277| 0| IGRAPH_ERROR("Object attribute expected.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
278| 0| break;
279| 0| default:
------------------
| Branch (279:13): [True: 0, False: 1]
------------------
280| 0| IGRAPH_ERROR("Attribute with unknown type expected.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
281| 0| break;
282| 1| }
283| 1| }
284| |
285| 1.60M| return IGRAPH_SUCCESS;
286| 1.60M|}
igraph_attribute_record_size:
295| 473k|igraph_int_t igraph_attribute_record_size(const igraph_attribute_record_t *attr) {
296| 473k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 473k| do { \
| | 925| 473k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 473k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 473k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 473k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 473k]
| | ------------------
------------------
297| |
298| 473k| switch (attr->type) {
299| 17.3k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (299:9): [True: 17.3k, False: 455k]
------------------
300| 17.3k| return igraph_vector_size(attr->value.as_vector);
301| |
302| 440k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (302:9): [True: 440k, False: 33.1k]
------------------
303| 440k| return igraph_strvector_size(attr->value.as_strvector);
304| |
305| 15.4k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (305:9): [True: 15.4k, False: 457k]
------------------
306| 15.4k| return igraph_vector_bool_size(attr->value.as_vector_bool);
307| |
308| 349| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (308:9): [True: 349, False: 472k]
------------------
309| 349| return 0;
310| |
311| 0| default:
------------------
| Branch (311:9): [True: 0, False: 473k]
------------------
312| 0| IGRAPH_ERRORF("Unsupported attribute type: %d", IGRAPH_EINVAL, (int) attr->type);
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
313| 473k| }
314| 473k|}
igraph_attribute_record_resize:
332| 435k|) {
333| 435k| igraph_int_t i;
334| 435k| igraph_vector_t *vec;
335| 435k| igraph_vector_bool_t *log;
336| 435k| igraph_strvector_t *str;
337| |
338| 435k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 435k| do { \
| | 925| 435k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 435k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 435k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 435k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 435k]
| | ------------------
------------------
339| |
340| 435k| switch (attr->type) {
341| |
342| 11.2k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (342:9): [True: 11.2k, False: 424k]
------------------
343| 11.2k| vec = attr->value.as_vector;
344| 11.2k| i = igraph_vector_size(vec);
345| 11.2k| IGRAPH_CHECK(igraph_vector_resize(vec, new_size));
------------------
| | 656| 11.2k| do { \
| | 657| 11.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 11.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.2k]
| | ------------------
------------------
346| 266k| while (i < new_size) {
------------------
| Branch (346:20): [True: 255k, False: 11.2k]
------------------
347| 255k| VECTOR(*vec)[i++] = attr->default_value.numeric;
------------------
| | 60| 255k|#define VECTOR(v) ((v).stor_begin)
------------------
348| 255k| }
349| 11.2k| break;
350| |
351| 13.6k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (351:9): [True: 13.6k, False: 422k]
------------------
352| 13.6k| log = attr->value.as_vector_bool;
353| 13.6k| i = igraph_vector_bool_size(log);
354| 13.6k| IGRAPH_CHECK(igraph_vector_bool_resize(log, new_size));
------------------
| | 656| 13.6k| do { \
| | 657| 13.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 13.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.6k]
| | ------------------
------------------
355| 36.1k| while (i < new_size) {
------------------
| Branch (355:20): [True: 22.5k, False: 13.6k]
------------------
356| 22.5k| VECTOR(*log)[i++] = attr->default_value.boolean;
------------------
| | 60| 22.5k|#define VECTOR(v) ((v).stor_begin)
------------------
357| 22.5k| }
358| 13.6k| break;
359| |
360| 411k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (360:9): [True: 411k, False: 24.8k]
------------------
361| 411k| str = attr->value.as_strvector;
362| 411k| if (attr->default_value.string == 0 || (*attr->default_value.string == 0)) {
------------------
| Branch (362:17): [True: 410k, False: 746]
| Branch (362:52): [True: 0, False: 746]
------------------
363| 410k| IGRAPH_CHECK(igraph_strvector_resize(str, new_size));
------------------
| | 656| 410k| do { \
| | 657| 410k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 410k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 410k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 410k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 410k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 410k]
| | ------------------
------------------
364| 410k| } else {
365| 746| i = igraph_strvector_size(str);
366| 746| IGRAPH_CHECK(igraph_strvector_resize(str, new_size));
------------------
| | 656| 746| do { \
| | 657| 746| igraph_error_t igraph_i_ret = (expr); \
| | 658| 746| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 746| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 746]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 746| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 746]
| | ------------------
------------------
367| 125k| while (i < new_size) {
------------------
| Branch (367:24): [True: 124k, False: 746]
------------------
368| 124k| IGRAPH_CHECK(igraph_strvector_set(str, i++, attr->default_value.string));
------------------
| | 656| 124k| do { \
| | 657| 124k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 124k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 124k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 124k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 124k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 124k]
| | ------------------
------------------
369| 124k| }
370| 746| }
371| 411k| break;
372| |
373| 411k| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (373:9): [True: 0, False: 435k]
------------------
374| 0| IGRAPH_ERROR("Attribute record has no type yet.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
375| 0| break;
376| |
377| 0| default:
------------------
| Branch (377:9): [True: 0, False: 435k]
------------------
378| 0| IGRAPH_ERRORF("Unsupported attribute type: %d", IGRAPH_EINVAL, (int) attr->type);
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
379| 435k| }
380| |
381| 435k| return IGRAPH_SUCCESS;
382| 435k|}
igraph_attribute_record_set_default_numeric:
399| 12.2k|) {
400| 12.2k| if (attr->type != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (400:9): [True: 0, False: 12.2k]
------------------
401| 0| return IGRAPH_EINVAL;
402| 0| }
403| |
404| 12.2k| attr->default_value.numeric = value;
405| 12.2k| return IGRAPH_SUCCESS;
406| 12.2k|}
igraph_attribute_record_set_default_boolean:
423| 1.44k|) {
424| 1.44k| if (attr->type != IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (424:9): [True: 0, False: 1.44k]
------------------
425| 0| return IGRAPH_EINVAL;
426| 0| }
427| |
428| 1.44k| attr->default_value.boolean = value;
429| 1.44k| return IGRAPH_SUCCESS;
430| 1.44k|}
igraph_attribute_record_set_default_string:
449| 973|) {
450| 973| char* copy;
451| |
452| 973| if (attr->type != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (452:9): [True: 0, False: 973]
------------------
453| 0| return IGRAPH_EINVAL;
454| 0| }
455| |
456| 973| if (value && (*value != 0)) {
------------------
| Branch (456:9): [True: 973, False: 0]
| Branch (456:18): [True: 973, False: 0]
------------------
457| 973| copy = strdup(value);
458| 973| IGRAPH_CHECK_OOM(copy, "Insufficient memory to duplicate default value.");
------------------
| | 709| 973| do { \
| | 710| 973| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 973| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 973]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 973| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 973]
| | ------------------
------------------
459| 973| } else {
460| 0| copy = NULL;
461| 0| }
462| |
463| 973| if (attr->default_value.string) {
------------------
| Branch (463:9): [True: 220, False: 753]
------------------
464| 220| igraph_free(attr->default_value.string);
465| 220| }
466| 973| attr->default_value.string = copy;
467| |
468| 973| return IGRAPH_SUCCESS;
469| 973|}
igraph_attribute_record_set_name:
483| 102k|) {
484| 102k| char *new_name;
485| |
486| 102k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 102k| do { \
| | 925| 102k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 102k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 102k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 102k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 102k]
| | ------------------
------------------
487| |
488| 102k| if (name != NULL) {
------------------
| Branch (488:9): [True: 63.1k, False: 39.5k]
------------------
489| 63.1k| new_name = strdup(name);
490| 63.1k| IGRAPH_CHECK_OOM(new_name, "Insufficient memory for allocating attribute name.");
------------------
| | 709| 63.1k| do { \
| | 710| 63.1k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 63.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 63.1k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 63.1k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 63.1k]
| | ------------------
------------------
491| 63.1k| } else {
492| 39.5k| new_name = NULL;
493| 39.5k| }
494| |
495| 102k| if (attr->name) {
------------------
| Branch (495:9): [True: 0, False: 102k]
------------------
496| 0| igraph_free(attr->name);
497| 0| }
498| |
499| 102k| attr->name = new_name;
500| |
501| 102k| return IGRAPH_SUCCESS;
502| 102k|}
igraph_attribute_record_set_type:
539| 102k|) {
540| 102k| void *ptr;
541| |
542| 102k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 102k| do { \
| | 925| 102k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 102k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 102k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 102k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 102k]
| | ------------------
------------------
543| |
544| 102k| if (attr->type != type) {
------------------
| Branch (544:9): [True: 62.5k, False: 40.2k]
------------------
545| 62.5k| switch (type) {
546| 11.8k| case IGRAPH_ATTRIBUTE_NUMERIC: {
------------------
| Branch (546:13): [True: 11.8k, False: 50.7k]
------------------
547| 11.8k| igraph_vector_t *vec = IGRAPH_CALLOC(1, igraph_vector_t);
------------------
| | 33| 11.8k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 23.6k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 11.8k, Folded]
| | | | ------------------
| | ------------------
------------------
548| 11.8k| IGRAPH_CHECK_OOM(vec, "Insufficient memory for attribute record.");
------------------
| | 709| 11.8k| do { \
| | 710| 11.8k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 11.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.8k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 11.8k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 11.8k]
| | ------------------
------------------
549| 11.8k| IGRAPH_FINALLY(igraph_free, vec);
------------------
| | 603| 11.8k| do { \
| | 604| 11.8k| /* the following branch makes the compiler check the compatibility of \
| | 605| 11.8k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 11.8k| * incorrect destructor function with the pointer */ \
| | 607| 11.8k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 11.8k]
| | ------------------
| | 608| 11.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 11.8k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 11.8k]
| | ------------------
------------------
550| 11.8k| IGRAPH_VECTOR_INIT_FINALLY(vec, 0);
------------------
| | 104| 11.8k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 11.8k| do { \
| | | | 657| 11.8k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 11.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 11.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 11.8k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 11.8k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 11.8k]
| | | | ------------------
| | ------------------
| | 105| 11.8k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 11.8k| do { \
| | | | 604| 11.8k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 11.8k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 11.8k| * incorrect destructor function with the pointer */ \
| | | | 607| 11.8k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 11.8k]
| | | | ------------------
| | | | 608| 11.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 11.8k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 11.8k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 11.8k]
| | ------------------
------------------
551| 11.8k| ptr = vec;
552| 11.8k| }
553| 0| break;
554| |
555| 45.8k| case IGRAPH_ATTRIBUTE_STRING: {
------------------
| Branch (555:13): [True: 45.8k, False: 16.7k]
------------------
556| 45.8k| igraph_strvector_t *strvec = IGRAPH_CALLOC(1, igraph_strvector_t);
------------------
| | 33| 45.8k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 91.6k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 45.8k, Folded]
| | | | ------------------
| | ------------------
------------------
557| 45.8k| IGRAPH_CHECK_OOM(strvec, "Insufficient memory for attribute record.");
------------------
| | 709| 45.8k| do { \
| | 710| 45.8k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 45.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 45.8k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 45.8k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 45.8k]
| | ------------------
------------------
558| 45.8k| IGRAPH_FINALLY(igraph_free, strvec);
------------------
| | 603| 45.8k| do { \
| | 604| 45.8k| /* the following branch makes the compiler check the compatibility of \
| | 605| 45.8k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 45.8k| * incorrect destructor function with the pointer */ \
| | 607| 45.8k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 45.8k]
| | ------------------
| | 608| 45.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 45.8k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 45.8k]
| | ------------------
------------------
559| 45.8k| IGRAPH_STRVECTOR_INIT_FINALLY(strvec, 0);
------------------
| | 62| 45.8k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 45.8k| do { \
| | | | 657| 45.8k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 45.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 45.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 45.8k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 45.8k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 45.8k]
| | | | ------------------
| | ------------------
| | 63| 45.8k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 45.8k| do { \
| | | | 604| 45.8k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 45.8k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 45.8k| * incorrect destructor function with the pointer */ \
| | | | 607| 45.8k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 45.8k]
| | | | ------------------
| | | | 608| 45.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 45.8k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 45.8k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 45.8k]
| | ------------------
------------------
560| 45.8k| ptr = strvec;
561| 45.8k| }
562| 0| break;
563| |
564| 4.90k| case IGRAPH_ATTRIBUTE_BOOLEAN: {
------------------
| Branch (564:13): [True: 4.90k, False: 57.6k]
------------------
565| 4.90k| igraph_vector_bool_t *boolvec = IGRAPH_CALLOC(1, igraph_vector_bool_t);
------------------
| | 33| 4.90k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 9.81k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 4.90k, Folded]
| | | | ------------------
| | ------------------
------------------
566| 4.90k| IGRAPH_CHECK_OOM(boolvec, "Insufficient memory for attribute record.");
------------------
| | 709| 4.90k| do { \
| | 710| 4.90k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 4.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.90k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 4.90k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 4.90k]
| | ------------------
------------------
567| 4.90k| IGRAPH_FINALLY(igraph_free, boolvec);
------------------
| | 603| 4.90k| do { \
| | 604| 4.90k| /* the following branch makes the compiler check the compatibility of \
| | 605| 4.90k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 4.90k| * incorrect destructor function with the pointer */ \
| | 607| 4.90k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 4.90k]
| | ------------------
| | 608| 4.90k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 4.90k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 4.90k]
| | ------------------
------------------
568| 4.90k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(boolvec, 0);
------------------
| | 109| 4.90k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 4.90k| do { \
| | | | 657| 4.90k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 4.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 4.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 4.90k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 4.90k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 4.90k]
| | | | ------------------
| | ------------------
| | 110| 4.90k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 4.90k| do { \
| | | | 604| 4.90k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 4.90k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 4.90k| * incorrect destructor function with the pointer */ \
| | | | 607| 4.90k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 4.90k]
| | | | ------------------
| | | | 608| 4.90k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 4.90k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 4.90k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 4.90k]
| | ------------------
------------------
569| 4.90k| ptr = boolvec;
570| 4.90k| }
571| 0| break;
572| |
573| 0| default:
------------------
| Branch (573:13): [True: 0, False: 62.5k]
------------------
574| 0| IGRAPH_FATALF("Unsupported attribute type: %d.", (int) type);
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
575| 62.5k| }
576| |
577| 62.5k| igraph_i_attribute_record_set_type(attr, type, ptr);
578| 62.5k| IGRAPH_FINALLY_CLEAN(2);
579| 62.5k| }
580| |
581| 102k| return IGRAPH_SUCCESS;
582| 102k|}
igraph_i_attribute_init:
617| 16.4k|) {
618| 16.4k| graph->attr = NULL;
619| 16.4k| if (igraph_i_attribute_table) {
------------------
| Branch (619:9): [True: 16.4k, False: 0]
------------------
620| 16.4k| IGRAPH_CHECK(igraph_i_attribute_table->init(graph, attr));
------------------
| | 656| 16.4k| do { \
| | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 16.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.4k]
| | ------------------
------------------
621| 16.4k| if (graph->attr == NULL) {
------------------
| Branch (621:13): [True: 0, False: 16.4k]
------------------
622| 0| IGRAPH_ERROR("Attribute handler did not initialize attr pointer", IGRAPH_FAILURE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
623| 0| }
624| 16.4k| }
625| 16.4k| return IGRAPH_SUCCESS;
626| 16.4k|}
igraph_i_attribute_destroy:
628| 16.4k|void igraph_i_attribute_destroy(igraph_t *graph) {
629| 16.4k| if (graph->attr && igraph_i_attribute_table) {
------------------
| Branch (629:9): [True: 16.4k, False: 0]
| Branch (629:24): [True: 16.4k, False: 0]
------------------
630| 16.4k| igraph_i_attribute_table->destroy(graph);
631| 16.4k| }
632| | graph->attr = NULL;
633| 16.4k|}
igraph_i_attribute_add_vertices:
649| 32.8k|) {
650| 32.8k| if (igraph_i_attribute_table) {
------------------
| Branch (650:9): [True: 32.8k, False: 0]
------------------
651| 32.8k| return igraph_i_attribute_table->add_vertices(graph, nv, attr);
652| 32.8k| } else {
653| 0| return IGRAPH_SUCCESS;
654| 0| }
655| 32.8k|}
igraph_i_attribute_add_edges:
690| 16.4k|) {
691| 16.4k| if (igraph_i_attribute_table) {
------------------
| Branch (691:9): [True: 16.4k, False: 0]
------------------
692| 16.4k| return igraph_i_attribute_table->add_edges(graph, edges, attr);
693| 16.4k| } else {
694| 0| return IGRAPH_SUCCESS;
695| 0| }
696| 16.4k|}
igraph_i_attribute_get_info:
734| 10.0k| igraph_vector_int_t *etypes) {
735| 10.0k| if (igraph_i_attribute_table) {
------------------
| Branch (735:9): [True: 10.0k, False: 0]
------------------
736| 10.0k| return igraph_i_attribute_table->get_info(graph, gnames, gtypes,
737| 10.0k| vnames, vtypes,
738| 10.0k| enames, etypes);
739| 10.0k| } else {
740| 0| return IGRAPH_SUCCESS;
741| 0| }
742| 10.0k|}
igraph_i_attribute_has_attr:
746| 210k| const char *name) {
747| 210k| if (igraph_i_attribute_table) {
------------------
| Branch (747:9): [True: 210k, False: 0]
------------------
748| 210k| return igraph_i_attribute_table->has_attr(graph, type, name);
749| 210k| } else {
750| 0| return IGRAPH_SUCCESS;
751| 0| }
752| 210k|}
igraph_i_attribute_get_type:
757| 2.71k| const char *name) {
758| 2.71k| if (igraph_i_attribute_table) {
------------------
| Branch (758:9): [True: 2.71k, False: 0]
------------------
759| 2.71k| return igraph_i_attribute_table->get_type(graph, type, elemtype, name);
760| 2.71k| } else {
761| 0| return IGRAPH_SUCCESS;
762| 0| }
763| |
764| 2.71k|}
igraph_i_attribute_get_numeric_graph_attr:
768| 325| igraph_vector_t *value) {
769| 325| igraph_vector_clear(value);
770| 325| if (igraph_i_attribute_table) {
------------------
| Branch (770:9): [True: 325, False: 0]
------------------
771| 325| return igraph_i_attribute_table->get_numeric_graph_attr(graph, name, value);
772| 325| } else {
773| 0| return IGRAPH_SUCCESS;
774| 0| }
775| 325|}
igraph_i_attribute_get_numeric_vertex_attr:
780| 14.1k| igraph_vector_t *value) {
781| 14.1k| igraph_vector_clear(value);
782| 14.1k| if (igraph_i_attribute_table) {
------------------
| Branch (782:9): [True: 14.1k, False: 0]
------------------
783| 14.1k| return igraph_i_attribute_table->get_numeric_vertex_attr(graph, name, vs, value);
784| 14.1k| } else {
785| 0| return IGRAPH_SUCCESS;
786| 0| }
787| 14.1k|}
igraph_i_attribute_get_numeric_edge_attr:
792| 390k| igraph_vector_t *value) {
793| 390k| igraph_vector_clear(value);
794| 390k| if (igraph_i_attribute_table) {
------------------
| Branch (794:9): [True: 390k, False: 0]
------------------
795| 390k| return igraph_i_attribute_table->get_numeric_edge_attr(graph, name, es, value);
796| 390k| } else {
797| 0| return IGRAPH_SUCCESS;
798| 0| }
799| 390k|}
igraph_i_attribute_get_string_graph_attr:
803| 1.79k| igraph_strvector_t *value) {
804| 1.79k| igraph_strvector_clear(value);
805| 1.79k| if (igraph_i_attribute_table) {
------------------
| Branch (805:9): [True: 1.79k, False: 0]
------------------
806| 1.79k| return igraph_i_attribute_table->get_string_graph_attr(graph, name, value);
807| 1.79k| } else {
808| 0| return IGRAPH_SUCCESS;
809| 0| }
810| 1.79k|}
igraph_i_attribute_get_string_vertex_attr:
815| 99.2k| igraph_strvector_t *value) {
816| 99.2k| igraph_strvector_clear(value);
817| 99.2k| if (igraph_i_attribute_table) {
------------------
| Branch (817:9): [True: 99.2k, False: 0]
------------------
818| 99.2k| return igraph_i_attribute_table->get_string_vertex_attr(graph, name, vs, value);
819| 99.2k| } else {
820| 0| return IGRAPH_SUCCESS;
821| 0| }
822| 99.2k|}
igraph_i_attribute_get_string_edge_attr:
827| 1.06M| igraph_strvector_t *value) {
828| 1.06M| igraph_strvector_clear(value);
829| 1.06M| if (igraph_i_attribute_table) {
------------------
| Branch (829:9): [True: 1.06M, False: 0]
------------------
830| 1.06M| return igraph_i_attribute_table->get_string_edge_attr(graph, name, es, value);
831| 1.06M| } else {
832| 0| return IGRAPH_SUCCESS;
833| 0| }
834| 1.06M|}
igraph_i_attribute_get_bool_graph_attr:
838| 417| igraph_vector_bool_t *value) {
839| 417| igraph_vector_bool_clear(value);
840| 417| if (igraph_i_attribute_table) {
------------------
| Branch (840:9): [True: 417, False: 0]
------------------
841| 417| return igraph_i_attribute_table->get_bool_graph_attr(graph, name, value);
842| 417| } else {
843| 0| return IGRAPH_SUCCESS;
844| 0| }
845| 417|}
igraph_i_attribute_get_bool_vertex_attr:
850| 14.2k| igraph_vector_bool_t *value) {
851| 14.2k| igraph_vector_bool_clear(value);
852| 14.2k| if (igraph_i_attribute_table) {
------------------
| Branch (852:9): [True: 14.2k, False: 0]
------------------
853| 14.2k| return igraph_i_attribute_table->get_bool_vertex_attr(graph, name, vs, value);
854| 14.2k| } else {
855| 0| return IGRAPH_SUCCESS;
856| 0| }
857| 14.2k|}
igraph_i_attribute_get_bool_edge_attr:
862| 20.0k| igraph_vector_bool_t *value) {
863| 20.0k| igraph_vector_bool_clear(value);
864| 20.0k| if (igraph_i_attribute_table) {
------------------
| Branch (864:9): [True: 20.0k, False: 0]
------------------
865| 20.0k| return igraph_i_attribute_table->get_bool_edge_attr(graph, name, es, value);
866| 20.0k| } else {
867| 0| return IGRAPH_SUCCESS;
868| 0| }
869| 20.0k|}
igraph_set_attribute_table:
895| 19.8k|igraph_set_attribute_table(const igraph_attribute_table_t * table) {
896| 19.8k| igraph_attribute_table_t *old = igraph_i_attribute_table;
897| 19.8k| igraph_i_attribute_table = (igraph_attribute_table_t*) table;
898| 19.8k| return old;
899| 19.8k|}
attributes.c:igraph_i_attribute_record_destroy_values:
185| 128k|static void igraph_i_attribute_record_destroy_values(igraph_attribute_record_t *attr) {
186| 128k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 128k| do { \
| | 925| 128k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 128k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 128k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 128k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 128k]
| | ------------------
------------------
187| |
188| 128k| if (attr->value.as_raw) {
------------------
| Branch (188:9): [True: 62.5k, False: 66.2k]
------------------
189| 62.5k| switch (attr->type) {
190| 11.8k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (190:13): [True: 11.8k, False: 50.7k]
------------------
191| 11.8k| igraph_vector_destroy(attr->value.as_vector);
192| 11.8k| break;
193| |
194| 45.8k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (194:13): [True: 45.8k, False: 16.7k]
------------------
195| 45.8k| igraph_strvector_destroy(attr->value.as_strvector);
196| 45.8k| break;
197| |
198| 4.90k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (198:13): [True: 4.90k, False: 57.6k]
------------------
199| 4.90k| igraph_vector_bool_destroy(attr->value.as_vector_bool);
200| 4.90k| break;
201| |
202| 0| default:
------------------
| Branch (202:13): [True: 0, False: 62.5k]
------------------
203| 0| break;
204| 62.5k| }
205| |
206| 62.5k| igraph_free(attr->value.as_raw);
207| 62.5k| attr->value.as_raw = NULL;
208| 62.5k| }
209| |
210| 128k| switch (attr->type) {
211| 11.8k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (211:9): [True: 11.8k, False: 116k]
------------------
212| 11.8k| attr->default_value.numeric = 0;
213| 11.8k| break;
214| |
215| 45.8k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (215:9): [True: 45.8k, False: 82.9k]
------------------
216| 45.8k| if (attr->default_value.string) {
------------------
| Branch (216:17): [True: 753, False: 45.0k]
------------------
217| 753| igraph_free(attr->default_value.string);
218| 753| attr->default_value.string = NULL;
219| 753| }
220| 45.8k| break;
221| |
222| 4.90k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (222:9): [True: 4.90k, False: 123k]
------------------
223| 4.90k| attr->default_value.boolean = 0;
224| 4.90k| break;
225| |
226| 66.2k| default:
------------------
| Branch (226:9): [True: 66.2k, False: 62.5k]
------------------
227| 66.2k| break;
228| 128k| }
229| |
230| 128k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
231| 128k|}
attributes.c:igraph_i_attribute_record_set_type:
506| 62.5k|) {
507| 62.5k| bool type_changed = attr->type != type;
508| |
509| 62.5k| if (type_changed || attr->value.as_raw != ptr) {
------------------
| Branch (509:9): [True: 62.5k, False: 0]
| Branch (509:25): [True: 0, False: 0]
------------------
510| 62.5k| igraph_i_attribute_record_destroy_values(attr);
511| 62.5k| attr->type = type;
512| 62.5k| attr->value.as_raw = ptr;
513| 62.5k| }
514| |
515| 62.5k| if (type_changed && type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (515:9): [True: 62.5k, False: 0]
| Branch (515:25): [True: 11.8k, False: 50.7k]
------------------
516| 11.8k| IGRAPH_ASSERT(
------------------
| | 924| 11.8k| do { \
| | 925| 11.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 11.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 11.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 11.8k]
| | ------------------
------------------
517| 11.8k| igraph_attribute_record_set_default_numeric(attr, IGRAPH_NAN) == IGRAPH_SUCCESS
518| 11.8k| );
519| 11.8k| }
520| 62.5k|}
attributes.c:igraph_i_attribute_record_list_init_item:
596| 39.5k|) {
597| 39.5k| IGRAPH_UNUSED(list);
------------------
| | 30| 39.5k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
598| | return igraph_attribute_record_init(item, NULL, IGRAPH_ATTRIBUTE_UNSPECIFIED);
599| 39.5k|}
attributes.c:igraph_i_attribute_record_list_copy_item:
603| 2.39k|) {
604| 2.39k| return igraph_attribute_record_init_copy(dest, source);
605| 2.39k|}
attributes.c:igraph_i_attribute_record_list_destroy_item:
607| 62.0k|static void igraph_i_attribute_record_list_destroy_item(igraph_attribute_record_t* item) {
608| 62.0k| igraph_attribute_record_destroy(item);
609| 62.0k|}
igraph_i_property_cache_init:
32| 16.4k|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) {
33| 16.4k| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32);
------------------
| | 68| 16.4k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
34| |
35| 16.4k| memset(cache->value, 0, sizeof(cache->value));
36| 16.4k| cache->known = 0;
37| 16.4k| return IGRAPH_SUCCESS;
38| 16.4k|}
igraph_i_property_cache_destroy:
53| 16.4k|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) {
54| 16.4k| IGRAPH_UNUSED(cache);
------------------
| | 30| 16.4k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
55| | /* Nothing to do */
56| 16.4k|}
igraph_i_property_cache_invalidate_conditionally:
182| 49.2k|) {
183| 49.2k| uint32_t invalidate = ~keep_always;
184| 49.2k| uint32_t mask;
185| 49.2k| uint32_t maybe_keep;
186| 49.2k| igraph_bool_t cached_value;
187| |
188| 49.2k| assert(graph->cache != NULL);
------------------
| Branch (188:5): [True: 0, False: 49.2k]
| Branch (188:5): [True: 49.2k, False: 0]
------------------
189| |
190| | /* The bits of maybe_keep are set to 1 for those properties that are:
191| | *
192| | * - currently cached
193| | * - should _probably_ be invalidated
194| | * - _but_ the current cached value of the property may change the decision
195| | */
196| 49.2k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true);
197| |
198| 49.2k| if (maybe_keep) {
------------------
| Branch (198:9): [True: 0, False: 49.2k]
------------------
199| 0| for (igraph_cached_property_t prop = (igraph_cached_property_t ) 0; prop < IGRAPH_PROP_I_SIZE; ++prop) {
------------------
| Branch (199:77): [True: 0, False: 0]
------------------
200| 0| mask = 1 << prop;
201| 0| if (maybe_keep & mask) {
------------------
| Branch (201:17): [True: 0, False: 0]
------------------
202| | /* if we get here, we know that the property is cached; we have
203| | * masked maybe_keep with graph->cache->known */
204| 0| cached_value = igraph_i_property_cache_get_bool(graph, prop);
205| 0| if (
206| 0| ((keep_when_false & mask) && !cached_value) ||
------------------
| Branch (206:22): [True: 0, False: 0]
| Branch (206:50): [True: 0, False: 0]
------------------
207| 0| ((keep_when_true & mask) && cached_value)
------------------
| Branch (207:22): [True: 0, False: 0]
| Branch (207:49): [True: 0, False: 0]
------------------
208| 0| ) {
209| 0| invalidate &= ~mask;
210| 0| }
211| 0| }
212| 0| }
213| 0| }
214| |
215| 49.2k| graph->cache->known &= ~invalidate;
216| 49.2k|}
cattributes.c:igraph_i_cattribute_init:
195| 16.4k|) {
196| 16.4k| igraph_i_cattributes_t *nattr;
197| |
198| 16.4k| nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t);
------------------
| | 33| 16.4k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 32.8k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 16.4k, Folded]
| | | | ------------------
| | ------------------
------------------
199| 16.4k| IGRAPH_CHECK_OOM(nattr, "Insufficient memory to allocate attribute storage.");
------------------
| | 709| 16.4k| do { \
| | 710| 16.4k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 16.4k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 16.4k]
| | ------------------
------------------
200| 16.4k| IGRAPH_FINALLY(igraph_free, nattr);
------------------
| | 603| 16.4k| do { \
| | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | 607| 16.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.4k]
| | ------------------
| | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.4k]
| | ------------------
------------------
201| |
202| 16.4k| if (attr) {
------------------
| Branch (202:9): [True: 9.98k, False: 6.44k]
------------------
203| 9.98k| IGRAPH_CHECK(igraph_attribute_record_list_init_copy(&nattr->gal, attr));
------------------
| | 656| 9.98k| do { \
| | 657| 9.98k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 9.98k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 9.98k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.98k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 9.98k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 9.98k]
| | ------------------
------------------
204| 9.98k| } else {
205| 6.44k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->gal, 0));
------------------
| | 656| 6.44k| do { \
| | 657| 6.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.44k]
| | ------------------
------------------
206| 6.44k| }
207| 16.4k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->gal);
------------------
| | 603| 16.4k| do { \
| | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | 607| 16.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.4k]
| | ------------------
| | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.4k]
| | ------------------
------------------
208| |
209| 16.4k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->val, 0));
------------------
| | 656| 16.4k| do { \
| | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 16.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.4k]
| | ------------------
------------------
210| 16.4k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->val);
------------------
| | 603| 16.4k| do { \
| | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | 607| 16.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.4k]
| | ------------------
| | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.4k]
| | ------------------
------------------
211| |
212| 16.4k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->eal, 0));
------------------
| | 656| 16.4k| do { \
| | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 16.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.4k]
| | ------------------
------------------
213| 16.4k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->eal);
------------------
| | 603| 16.4k| do { \
| | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | 607| 16.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.4k]
| | ------------------
| | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.4k]
| | ------------------
------------------
214| |
215| 16.4k| graph->attr = nattr;
216| 16.4k| IGRAPH_FINALLY_CLEAN(4);
217| |
218| 16.4k| return IGRAPH_SUCCESS;
219| 16.4k|}
cattributes.c:igraph_i_cattribute_destroy:
221| 16.4k|static void igraph_i_cattribute_destroy(igraph_t *graph) {
222| 16.4k| igraph_i_cattributes_t *attr = graph->attr;
223| 16.4k| igraph_attribute_record_list_destroy(&attr->eal);
224| 16.4k| igraph_attribute_record_list_destroy(&attr->val);
225| 16.4k| igraph_attribute_record_list_destroy(&attr->gal);
226| | IGRAPH_FREE(graph->attr); /* sets to NULL */
------------------
| | 36| 16.4k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
227| 16.4k|}
cattributes.c:igraph_i_cattribute_add_vertices:
373| 32.8k|) {
374| 32.8k| igraph_i_cattributes_t *attr = graph->attr;
375| 32.8k| return igraph_i_cattribute_add_vertices_or_edges(&attr->val, igraph_vcount(graph), nv, nattr);
376| 32.8k|}
cattributes.c:igraph_i_cattribute_add_vertices_or_edges:
344| 49.2k|) {
345| 49.2k| igraph_int_t origlen = newlen - nv;
346| 49.2k| igraph_error_t err = igraph_i_cattribute_add_vertices_or_edges_inner(
347| 49.2k| val, newlen, nv, nattr
348| 49.2k| );
349| |
350| 49.2k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (350:9): [True: 0, False: 49.2k]
------------------
351| | /* If unsuccessful, revert attribute vector sizes.
352| | * The following function assumes that all attributes vectors that
353| | * are present have a length at least as great as origlen.
354| | * This is true at the moment because any new attributes that are
355| | * added to the graph are created directly at 'origlen' instead of
356| | * being created at smaller sizes and resized later.
357| | *
358| | * NOTE: While this ensures that all attribute vector lengths are
359| | * correct, it does not ensure that no extra attributes have
360| | * been added to the graph. However, the presence of extra
361| | * attributes does not make the attribute table inconsistent
362| | * like the incorrect attribute vector lengths would.
363| | */
364| 0| igraph_i_cattribute_revert_attribute_vector_sizes(val, origlen);
365| 0| }
366| |
367| 49.2k| return err;
368| 49.2k|}
cattributes.c:igraph_i_cattribute_add_vertices_or_edges_inner:
269| 49.2k|) {
270| 49.2k| igraph_int_t length;
271| 49.2k| igraph_int_t nattrno = nattr == NULL ? 0 : igraph_attribute_record_list_size(nattr);
------------------
| Branch (271:28): [True: 22.5k, False: 26.7k]
------------------
272| 49.2k| igraph_int_t origlen = newlen - nv;
273| |
274| 49.2k| IGRAPH_ASSERT(origlen >= 0);
------------------
| | 924| 49.2k| do { \
| | 925| 49.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 49.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 49.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 49.2k]
| | ------------------
------------------
275| |
276| | /* Find all the attributes that are newly added, and create new value vectors
277| | * for them in the original graph */
278| 77.8k| for (igraph_int_t i = 0; i < nattrno; i++) {
------------------
| Branch (278:30): [True: 28.6k, False: 49.2k]
------------------
279| 28.6k| const igraph_attribute_record_t *nattr_entry = igraph_attribute_record_list_get_ptr(nattr, i);
280| 28.6k| const char *nname = nattr_entry->name;
281| 28.6k| IGRAPH_CHECK(igraph_i_cattribute_find_or_create(val, nname, nattr_entry->type, origlen, NULL));
------------------
| | 656| 28.6k| do { \
| | 657| 28.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 28.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 28.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 28.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 28.6k]
| | ------------------
------------------
282| 28.6k| }
283| |
284| | /* Now append the new values */
285| 49.2k| length = igraph_attribute_record_list_size(val);
286| 77.8k| for (igraph_int_t i = 0; i < length; i++) {
------------------
| Branch (286:30): [True: 28.6k, False: 49.2k]
------------------
287| 28.6k| igraph_attribute_record_t *oldrec = igraph_attribute_record_list_get_ptr(val, i);
288| 28.6k| const igraph_attribute_record_t *newrec = nattr
------------------
| Branch (288:51): [True: 28.6k, False: 0]
------------------
289| 28.6k| ? igraph_i_cattribute_find_const(nattr, oldrec->name, oldrec->type)
290| 28.6k| : NULL;
291| |
292| 28.6k| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == origlen);
------------------
| | 924| 28.6k| do { \
| | 925| 28.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 28.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 28.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 28.6k]
| | ------------------
------------------
293| |
294| 28.6k| if (newrec) {
------------------
| Branch (294:13): [True: 28.6k, False: 0]
------------------
295| | /* This attribute is present in nattr */
296| 28.6k| switch (oldrec->type) {
297| 5.47k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (297:13): [True: 5.47k, False: 23.1k]
------------------
298| 5.47k| if (nv != igraph_vector_size(newrec->value.as_vector)) {
------------------
| Branch (298:21): [True: 0, False: 5.47k]
------------------
299| 0| IGRAPH_ERROR("Invalid numeric attribute length.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
300| 0| }
301| 5.47k| IGRAPH_CHECK(igraph_vector_append(
------------------
| | 656| 5.47k| do { \
| | 657| 5.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.47k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.47k]
| | ------------------
------------------
302| 5.47k| oldrec->value.as_vector, newrec->value.as_vector
303| 5.47k| ));
304| 5.47k| break;
305| 21.0k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (305:13): [True: 21.0k, False: 7.53k]
------------------
306| 21.0k| if (nv != igraph_strvector_size(newrec->value.as_strvector)) {
------------------
| Branch (306:21): [True: 0, False: 21.0k]
------------------
307| 0| IGRAPH_ERROR("Invalid string attribute length.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
308| 0| }
309| 21.0k| IGRAPH_CHECK(igraph_strvector_append(
------------------
| | 656| 21.0k| do { \
| | 657| 21.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 21.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 21.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 21.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 21.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 21.0k]
| | ------------------
------------------
310| 21.0k| oldrec->value.as_strvector, newrec->value.as_strvector
311| 21.0k| ));
312| 21.0k| break;
313| 21.0k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (313:13): [True: 2.06k, False: 26.5k]
------------------
314| 2.06k| if (nv != igraph_vector_bool_size(newrec->value.as_vector_bool)) {
------------------
| Branch (314:21): [True: 0, False: 2.06k]
------------------
315| 0| IGRAPH_ERROR("Invalid boolean attribute length.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
316| 0| }
317| 2.06k| IGRAPH_CHECK(igraph_vector_bool_append(
------------------
| | 656| 2.06k| do { \
| | 657| 2.06k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.06k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.06k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.06k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.06k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.06k]
| | ------------------
------------------
318| 2.06k| oldrec->value.as_vector_bool, newrec->value.as_vector_bool
319| 2.06k| ));
320| 2.06k| break;
321| 2.06k| default:
------------------
| Branch (321:13): [True: 0, False: 28.6k]
------------------
322| 0| IGRAPH_WARNINGF(
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
323| 0| "Attribute '%s' with unknown type %d ignored",
324| 0| oldrec->name, (int) oldrec->type
325| 0| );
326| 0| break;
327| 28.6k| }
328| 28.6k| } else {
329| | /* No such attribute among the new ones so just extend the length
330| | * of the current record */
331| 0| IGRAPH_CHECK(igraph_attribute_record_resize(oldrec, newlen));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
332| 0| }
333| |
334| 28.6k| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == newlen);
------------------
| | 924| 28.6k| do { \
| | 925| 28.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 28.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 28.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 28.6k]
| | ------------------
------------------
335| 28.6k| }
336| |
337| 49.2k| return IGRAPH_SUCCESS;
338| 49.2k|}
cattributes.c:igraph_i_cattribute_find_const:
90| 28.6k|) {
91| 28.6k| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name);
92| 28.6k| const igraph_attribute_record_t *rec;
93| |
94| 28.6k| if (index >= 0) {
------------------
| Branch (94:9): [True: 28.6k, False: 0]
------------------
95| 28.6k| rec = igraph_attribute_record_list_get_ptr(attrs, index);
96| 28.6k| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) {
------------------
| Branch (96:13): [True: 0, False: 28.6k]
| Branch (96:53): [True: 28.6k, False: 0]
------------------
97| 28.6k| return rec;
98| 28.6k| }
99| 28.6k| }
100| |
101| 0| return NULL;
102| 28.6k|}
cattributes.c:igraph_i_cattribute_add_edges:
1463| 16.4k|) {
1464| 16.4k| igraph_int_t ne = igraph_vector_int_size(edges) / 2;
1465| 16.4k| igraph_i_cattributes_t *attr = graph->attr;
1466| 16.4k| return igraph_i_cattribute_add_vertices_or_edges(&attr->eal, igraph_ecount(graph), ne, nattr);
1467| 16.4k|}
cattributes.c:igraph_i_cattribute_get_info:
1498| 10.0k| igraph_vector_int_t *etypes) {
1499| |
1500| 10.0k| igraph_strvector_t *names[3] = { gnames, vnames, enames };
1501| 10.0k| igraph_vector_int_t *types[3] = { gtypes, vtypes, etypes };
1502| 10.0k| igraph_i_cattributes_t *at = graph->attr;
1503| 10.0k| igraph_attribute_record_list_t *attr[3] = { &at->gal, &at->val, &at->eal };
1504| |
1505| 40.0k| for (igraph_int_t i = 0; i < 3; i++) {
------------------
| Branch (1505:30): [True: 30.0k, False: 10.0k]
------------------
1506| 30.0k| igraph_strvector_t *n = names[i];
1507| 30.0k| igraph_vector_int_t *t = types[i];
1508| 30.0k| const igraph_attribute_record_list_t *al = attr[i];
1509| 30.0k| igraph_int_t len = igraph_attribute_record_list_size(al);
1510| |
1511| 30.0k| if (n) {
------------------
| Branch (1511:13): [True: 30.0k, False: 0]
------------------
1512| 30.0k| IGRAPH_CHECK(igraph_strvector_resize(n, len));
------------------
| | 656| 30.0k| do { \
| | 657| 30.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 30.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 30.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 30.0k]
| | ------------------
------------------
1513| 30.0k| }
1514| 30.0k| if (t) {
------------------
| Branch (1514:13): [True: 30.0k, False: 0]
------------------
1515| 30.0k| IGRAPH_CHECK(igraph_vector_int_resize(t, len));
------------------
| | 656| 30.0k| do { \
| | 657| 30.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 30.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 30.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 30.0k]
| | ------------------
------------------
1516| 30.0k| }
1517| |
1518| 56.2k| for (igraph_int_t j = 0; j < len; j++) {
------------------
| Branch (1518:34): [True: 26.1k, False: 30.0k]
------------------
1519| 26.1k| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(al, j);
1520| 26.1k| const char *name = rec->name;
1521| 26.1k| igraph_attribute_type_t type = rec->type;
1522| 26.1k| if (n) {
------------------
| Branch (1522:17): [True: 26.1k, False: 0]
------------------
1523| 26.1k| IGRAPH_CHECK(igraph_strvector_set(n, j, name));
------------------
| | 656| 26.1k| do { \
| | 657| 26.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 26.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 26.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 26.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 26.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 26.1k]
| | ------------------
------------------
1524| 26.1k| }
1525| 26.1k| if (t) {
------------------
| Branch (1525:17): [True: 26.1k, False: 0]
------------------
1526| 26.1k| VECTOR(*t)[j] = type;
------------------
| | 60| 26.1k|#define VECTOR(v) ((v).stor_begin)
------------------
1527| 26.1k| }
1528| 26.1k| }
1529| 30.0k| }
1530| |
1531| 10.0k| return IGRAPH_SUCCESS;
1532| 10.0k|}
cattributes.c:igraph_i_cattribute_has_attr:
1536| 210k| const char *name) {
1537| 210k| const igraph_i_cattributes_t *at = graph->attr;
1538| 210k| switch (type) {
1539| 0| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (1539:5): [True: 0, False: 210k]
------------------
1540| 0| return igraph_i_cattribute_find_index(&at->gal, name) >= 0;
1541| 130k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (1541:5): [True: 130k, False: 80.1k]
------------------
1542| 130k| return igraph_i_cattribute_find_index(&at->val, name) >= 0;
1543| 80.1k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (1543:5): [True: 80.1k, False: 130k]
------------------
1544| 80.1k| return igraph_i_cattribute_find_index(&at->eal, name) >= 0;
1545| 0| default:
------------------
| Branch (1545:5): [True: 0, False: 210k]
------------------
1546| 0| IGRAPH_ERROR("Unknown attribute element type.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1547| 0| break;
1548| 210k| }
1549| |
1550| 0| return false;
1551| 210k|}
cattributes.c:igraph_i_cattribute_get_type:
1556| 2.71k| const char *name) {
1557| 2.71k| igraph_attribute_record_t *rec;
1558| 2.71k| igraph_i_cattributes_t *at = graph->attr;
1559| 2.71k| igraph_attribute_record_list_t *al;
1560| |
1561| 2.71k| switch (elemtype) {
1562| 0| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (1562:5): [True: 0, False: 2.71k]
------------------
1563| 0| al = &at->gal;
1564| 0| break;
1565| 1.63k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (1565:5): [True: 1.63k, False: 1.07k]
------------------
1566| 1.63k| al = &at->val;
1567| 1.63k| break;
1568| 1.07k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (1568:5): [True: 1.07k, False: 1.63k]
------------------
1569| 1.07k| al = &at->eal;
1570| 1.07k| break;
1571| 0| default:
------------------
| Branch (1571:5): [True: 0, False: 2.71k]
------------------
1572| 0| IGRAPH_ERROR("Unknown attribute element type.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1573| 0| break;
1574| 2.71k| }
1575| |
1576| 2.71k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(al, name, IGRAPH_ATTRIBUTE_UNSPECIFIED, &rec));
------------------
| | 656| 2.71k| do { \
| | 657| 2.71k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.71k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.71k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.71k]
| | ------------------
------------------
1577| 2.71k| *type = rec->type;
1578| |
1579| 2.71k| return IGRAPH_SUCCESS;
1580| 2.71k|}
cattributes.c:igraph_i_cattribute_find_or_return:
113| 1.61M|) {
114| 1.61M| igraph_attribute_record_t *rec;
115| |
116| 1.61M| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED);
117| 1.61M| if (!rec) {
------------------
| Branch (117:9): [True: 9, False: 1.61M]
------------------
118| 9| IGRAPH_ERRORF("Attribute '%s' does not exist.", IGRAPH_EINVAL, name);
------------------
| | 464| 9| do { \
| | 465| 9| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 9| igraph_errno, __VA_ARGS__) ; \
| | 467| 9| return igraph_errno; \
| | 468| 9| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
119| 9| }
120| |
121| 1.61M| if (type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (121:9): [True: 1.60M, False: 2.71k]
------------------
122| 1.60M| IGRAPH_CHECK(igraph_attribute_record_check_type(rec, type));
------------------
| | 656| 1.60M| do { \
| | 657| 1.60M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.60M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.60M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 1.60M]
| | | | ------------------
| | ------------------
| | 659| 1| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 1| do { \
| | | | 427| 1| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 1| return igraph_errno ; \
| | | | 429| 1| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 1| } \
| | 661| 1.60M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.60M]
| | ------------------
------------------
123| 1.60M| }
124| |
125| 1.61M| if (ptr) {
------------------
| Branch (125:9): [True: 1.61M, False: 0]
------------------
126| 1.61M| *ptr = rec;
127| 1.61M| }
128| |
129| 1.61M| return IGRAPH_SUCCESS;
130| 1.61M|}
cattributes.c:igraph_i_cattribute_get_numeric_graph_attr:
1584| 325|) {
1585| 325| igraph_i_cattributes_t *attr = graph->attr;
1586| 325| igraph_attribute_record_list_t *gal = &attr->gal;
1587| 325| igraph_attribute_record_t *rec;
1588| |
1589| 325| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_NUMERIC, &rec));
------------------
| | 656| 325| do { \
| | 657| 325| igraph_error_t igraph_i_ret = (expr); \
| | 658| 325| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 325| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 325]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 325| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 325]
| | ------------------
------------------
1590| 325| IGRAPH_CHECK(igraph_vector_push_back(value, VECTOR(*rec->value.as_vector)[0]));
------------------
| | 656| 325| do { \
| | 657| 325| igraph_error_t igraph_i_ret = (expr); \
| | 658| 325| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 325| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 325]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 325| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 325]
| | ------------------
------------------
1591| |
1592| 325| return IGRAPH_SUCCESS;
1593| 325|}
cattributes.c:igraph_i_cattribute_get_string_graph_attr:
1610| 1.79k|) {
1611| 1.79k| igraph_i_cattributes_t *attr = graph->attr;
1612| 1.79k| igraph_attribute_record_list_t *gal = &attr->gal;
1613| 1.79k| igraph_attribute_record_t *rec;
1614| |
1615| 1.79k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 656| 1.79k| do { \
| | 657| 1.79k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.79k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.79k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.79k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.79k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.79k]
| | ------------------
------------------
1616| 1.79k| IGRAPH_CHECK(igraph_strvector_push_back(value, igraph_strvector_get(rec->value.as_strvector, 0)));
------------------
| | 656| 1.79k| do { \
| | 657| 1.79k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.79k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.79k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.79k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.79k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.79k]
| | ------------------
------------------
1617| |
1618| 1.79k| return IGRAPH_SUCCESS;
1619| 1.79k|}
cattributes.c:igraph_i_cattribute_get_bool_graph_attr:
1597| 417|) {
1598| 417| igraph_i_cattributes_t *attr = graph->attr;
1599| 417| igraph_attribute_record_list_t *gal = &attr->gal;
1600| 417| igraph_attribute_record_t *rec;
1601| |
1602| 417| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 417| do { \
| | 657| 417| igraph_error_t igraph_i_ret = (expr); \
| | 658| 417| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 417| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 417| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 417]
| | ------------------
------------------
1603| 417| IGRAPH_CHECK(igraph_vector_bool_push_back(value, VECTOR(*rec->value.as_vector_bool)[0]));
------------------
| | 656| 417| do { \
| | 657| 417| igraph_error_t igraph_i_ret = (expr); \
| | 658| 417| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 417| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 417| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 417]
| | ------------------
------------------
1604| |
1605| 417| return IGRAPH_SUCCESS;
1606| 417|}
cattributes.c:igraph_i_cattribute_get_numeric_vertex_attr:
1624| 14.1k| igraph_vector_t *value) {
1625| 14.1k| igraph_i_cattributes_t *attr = graph->attr;
1626| 14.1k| igraph_attribute_record_list_t *val = &attr->val;
1627| 14.1k| igraph_attribute_record_t *rec;
1628| 14.1k| const igraph_vector_t *num;
1629| |
1630| 14.1k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_NUMERIC, &rec));
------------------
| | 656| 14.1k| do { \
| | 657| 14.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.1k]
| | ------------------
------------------
1631| |
1632| 14.1k| num = rec->value.as_vector;
1633| 14.1k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1633:9): [True: 70, False: 14.0k]
------------------
1634| 70| IGRAPH_CHECK(igraph_vector_append(value, num));
------------------
| | 656| 70| do { \
| | 657| 70| igraph_error_t igraph_i_ret = (expr); \
| | 658| 70| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 70| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 70]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 70| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 70]
| | ------------------
------------------
1635| 14.0k| } else {
1636| 14.0k| igraph_vit_t it;
1637| 14.0k| igraph_int_t i = igraph_vector_size(value);
1638| 14.0k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 656| 14.0k| do { \
| | 657| 14.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.0k]
| | ------------------
------------------
1639| 14.0k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 603| 14.0k| do { \
| | 604| 14.0k| /* the following branch makes the compiler check the compatibility of \
| | 605| 14.0k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 14.0k| * incorrect destructor function with the pointer */ \
| | 607| 14.0k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 14.0k]
| | ------------------
| | 608| 14.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 14.0k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 14.0k]
| | ------------------
------------------
1640| 14.0k| IGRAPH_CHECK(igraph_vector_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 656| 14.0k| do { \
| | 657| 14.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.0k]
| | ------------------
------------------
1641| 28.0k| for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 179| 28.0k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end)
------------------
for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 167| 14.0k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1641:16): [True: 14.0k, False: 14.0k]
------------------
1642| 14.0k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 14.0k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 14.0k, False: 0]
| | ------------------
| | 215| 14.0k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1643| 14.0k| VECTOR(*value)[i] = VECTOR(*num)[v];
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*num)[v];
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
1644| 14.0k| }
1645| 14.0k| igraph_vit_destroy(&it);
1646| 14.0k| IGRAPH_FINALLY_CLEAN(1);
1647| 14.0k| }
1648| |
1649| 14.1k| return IGRAPH_SUCCESS;
1650| 14.1k|}
cattributes.c:igraph_i_cattribute_get_string_vertex_attr:
1686| 99.2k| igraph_strvector_t *value) {
1687| 99.2k| igraph_i_cattributes_t *attr = graph->attr;
1688| 99.2k| igraph_attribute_record_list_t *val = &attr->val;
1689| 99.2k| igraph_attribute_record_t *rec;
1690| 99.2k| const igraph_strvector_t *str;
1691| |
1692| 99.2k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 656| 99.2k| do { \
| | 657| 99.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 99.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 99.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 99.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 99.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 99.2k]
| | ------------------
------------------
1693| |
1694| 99.2k| str = rec->value.as_strvector;
1695| 99.2k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1695:9): [True: 1.25k, False: 97.9k]
------------------
1696| 1.25k| igraph_strvector_clear(value);
1697| 1.25k| IGRAPH_CHECK(igraph_strvector_append(value, str));
------------------
| | 656| 1.25k| do { \
| | 657| 1.25k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.25k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.25k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.25k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.25k]
| | ------------------
------------------
1698| 97.9k| } else {
1699| 97.9k| igraph_vit_t it;
1700| 97.9k| igraph_int_t i = igraph_strvector_size(value);
1701| 97.9k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 656| 97.9k| do { \
| | 657| 97.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 97.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 97.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 97.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 97.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 97.9k]
| | ------------------
------------------
1702| 97.9k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 603| 97.9k| do { \
| | 604| 97.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 97.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 97.9k| * incorrect destructor function with the pointer */ \
| | 607| 97.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 97.9k]
| | ------------------
| | 608| 97.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 97.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 97.9k]
| | ------------------
------------------
1703| 97.9k| IGRAPH_CHECK(igraph_strvector_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 656| 97.9k| do { \
| | 657| 97.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 97.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 97.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 97.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 97.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 97.9k]
| | ------------------
------------------
1704| 195k| for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 179| 195k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end)
------------------
for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 167| 97.9k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1704:16): [True: 97.9k, False: 97.9k]
------------------
1705| 97.9k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 97.9k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 97.9k, False: 0]
| | ------------------
| | 215| 97.9k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1706| 97.9k| IGRAPH_CHECK(igraph_strvector_set(value, i, igraph_strvector_get(str, v)));
------------------
| | 656| 97.9k| do { \
| | 657| 97.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 97.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 97.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 97.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 97.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 97.9k]
| | ------------------
------------------
1707| 97.9k| }
1708| 97.9k| igraph_vit_destroy(&it);
1709| 97.9k| IGRAPH_FINALLY_CLEAN(1);
1710| 97.9k| }
1711| |
1712| 99.2k| return IGRAPH_SUCCESS;
1713| 99.2k|}
cattributes.c:igraph_i_cattribute_get_bool_vertex_attr:
1655| 14.2k| igraph_vector_bool_t *value) {
1656| 14.2k| igraph_i_cattributes_t *attr = graph->attr;
1657| 14.2k| igraph_attribute_record_list_t *val = &attr->val;
1658| 14.2k| igraph_attribute_record_t *rec;
1659| 14.2k| const igraph_vector_bool_t *log;
1660| |
1661| 14.2k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
1662| |
1663| 14.2k| log = rec->value.as_vector_bool;
1664| 14.2k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1664:9): [True: 29, False: 14.1k]
------------------
1665| 29| IGRAPH_CHECK(igraph_vector_bool_append(value, log));
------------------
| | 656| 29| do { \
| | 657| 29| igraph_error_t igraph_i_ret = (expr); \
| | 658| 29| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 29| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 29]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 29| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 29]
| | ------------------
------------------
1666| 14.1k| } else {
1667| 14.1k| igraph_vit_t it;
1668| 14.1k| igraph_int_t i = igraph_vector_bool_size(value);
1669| 14.1k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 656| 14.1k| do { \
| | 657| 14.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.1k]
| | ------------------
------------------
1670| 14.1k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 603| 14.1k| do { \
| | 604| 14.1k| /* the following branch makes the compiler check the compatibility of \
| | 605| 14.1k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 14.1k| * incorrect destructor function with the pointer */ \
| | 607| 14.1k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 14.1k]
| | ------------------
| | 608| 14.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 14.1k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 14.1k]
| | ------------------
------------------
1671| 14.1k| IGRAPH_CHECK(igraph_vector_bool_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 656| 14.1k| do { \
| | 657| 14.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.1k]
| | ------------------
------------------
1672| 28.3k| for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 179| 28.3k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end)
------------------
for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 167| 14.1k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1672:16): [True: 14.1k, False: 14.1k]
------------------
1673| 14.1k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 14.1k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 14.1k, False: 0]
| | ------------------
| | 215| 14.1k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1674| 14.1k| VECTOR(*value)[i] = VECTOR(*log)[v];
------------------
| | 60| 14.1k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*log)[v];
------------------
| | 60| 14.1k|#define VECTOR(v) ((v).stor_begin)
------------------
1675| 14.1k| }
1676| 14.1k| igraph_vit_destroy(&it);
1677| 14.1k| IGRAPH_FINALLY_CLEAN(1);
1678| 14.1k| }
1679| |
1680| 14.2k| return IGRAPH_SUCCESS;
1681| 14.2k|}
cattributes.c:igraph_i_cattribute_get_numeric_edge_attr:
1717| 390k|) {
1718| 390k| igraph_i_cattributes_t *attr = graph->attr;
1719| 390k| igraph_attribute_record_list_t *eal = &attr->eal;
1720| 390k| igraph_attribute_record_t *rec;
1721| 390k| const igraph_vector_t *num;
1722| |
1723| 390k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_NUMERIC, &rec));
------------------
| | 656| 390k| do { \
| | 657| 390k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 390k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 390k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 390k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 390k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 390k]
| | ------------------
------------------
1724| |
1725| 390k| num = rec->value.as_vector;
1726| 390k| if (igraph_es_is_all(&es)) {
------------------
| Branch (1726:9): [True: 542, False: 389k]
------------------
1727| 542| IGRAPH_CHECK(igraph_vector_append(value, num));
------------------
| | 656| 542| do { \
| | 657| 542| igraph_error_t igraph_i_ret = (expr); \
| | 658| 542| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 542| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 542]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 542| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 542]
| | ------------------
------------------
1728| 389k| } else {
1729| 389k| igraph_eit_t it;
1730| 389k| igraph_int_t i = igraph_vector_size(value);
1731| 389k| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 656| 389k| do { \
| | 657| 389k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 389k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 389k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 389k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 389k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 389k]
| | ------------------
------------------
1732| 389k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 389k| do { \
| | 604| 389k| /* the following branch makes the compiler check the compatibility of \
| | 605| 389k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 389k| * incorrect destructor function with the pointer */ \
| | 607| 389k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 389k]
| | ------------------
| | 608| 389k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 389k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 389k]
| | ------------------
------------------
1733| 389k| IGRAPH_CHECK(igraph_vector_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 656| 389k| do { \
| | 657| 389k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 389k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 389k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 389k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 389k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 389k]
| | ------------------
------------------
1734| 779k| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 779k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 389k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1734:16): [True: 389k, False: 389k]
------------------
1735| 389k| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 389k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 389k, False: 0]
| | ------------------
| | 406| 389k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1736| 389k| VECTOR(*value)[i] = VECTOR(*num)[e];
------------------
| | 60| 389k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*num)[e];
------------------
| | 60| 389k|#define VECTOR(v) ((v).stor_begin)
------------------
1737| 389k| }
1738| 389k| igraph_eit_destroy(&it);
1739| 389k| IGRAPH_FINALLY_CLEAN(1);
1740| 389k| }
1741| |
1742| 390k| return IGRAPH_SUCCESS;
1743| 390k|}
cattributes.c:igraph_i_cattribute_get_string_edge_attr:
1748| 1.06M|) {
1749| 1.06M| igraph_i_cattributes_t *attr = graph->attr;
1750| 1.06M| igraph_attribute_record_list_t *eal = &attr->eal;
1751| 1.06M| igraph_attribute_record_t *rec;
1752| 1.06M| const igraph_strvector_t *str;
1753| |
1754| 1.06M| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 656| 1.06M| do { \
| | 657| 1.06M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.06M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.06M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.06M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.06M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.06M]
| | ------------------
------------------
1755| |
1756| 1.06M| str = rec->value.as_strvector;
1757| 1.06M| if (igraph_es_is_all(&es)) {
------------------
| Branch (1757:9): [True: 50, False: 1.06M]
------------------
1758| 50| IGRAPH_CHECK(igraph_strvector_append(value, str));
------------------
| | 656| 50| do { \
| | 657| 50| igraph_error_t igraph_i_ret = (expr); \
| | 658| 50| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 50| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 50]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 50| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 50]
| | ------------------
------------------
1759| 1.06M| } else {
1760| 1.06M| igraph_eit_t it;
1761| 1.06M| igraph_int_t i = igraph_strvector_size(value);
1762| 1.06M| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 656| 1.06M| do { \
| | 657| 1.06M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.06M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.06M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.06M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.06M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.06M]
| | ------------------
------------------
1763| 1.06M| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 1.06M| do { \
| | 604| 1.06M| /* the following branch makes the compiler check the compatibility of \
| | 605| 1.06M| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 1.06M| * incorrect destructor function with the pointer */ \
| | 607| 1.06M| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 1.06M]
| | ------------------
| | 608| 1.06M| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 1.06M| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 1.06M]
| | ------------------
------------------
1764| 1.06M| IGRAPH_CHECK(igraph_strvector_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 656| 1.06M| do { \
| | 657| 1.06M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.06M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.06M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.06M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.06M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.06M]
| | ------------------
------------------
1765| 2.13M| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 2.13M|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 1.06M|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1765:16): [True: 1.06M, False: 1.06M]
------------------
1766| 1.06M| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 1.06M| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 1.06M, False: 0]
| | ------------------
| | 406| 1.06M| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1767| 1.06M| IGRAPH_CHECK(igraph_strvector_set(value, i, igraph_strvector_get(str, e)));
------------------
| | 656| 1.06M| do { \
| | 657| 1.06M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.06M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.06M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.06M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.06M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.06M]
| | ------------------
------------------
1768| 1.06M| }
1769| 1.06M| igraph_eit_destroy(&it);
1770| 1.06M| IGRAPH_FINALLY_CLEAN(1);
1771| 1.06M| }
1772| |
1773| 1.06M| return IGRAPH_SUCCESS;
1774| 1.06M|}
cattributes.c:igraph_i_cattribute_get_bool_edge_attr:
1779| 20.0k|) {
1780| 20.0k| igraph_i_cattributes_t *attr = graph->attr;
1781| 20.0k| igraph_attribute_record_list_t *eal = &attr->eal;
1782| 20.0k| igraph_attribute_record_t *rec;
1783| 20.0k| const igraph_vector_bool_t *log;
1784| |
1785| 20.0k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 20.0k| do { \
| | 657| 20.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 20.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 20.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 10, False: 19.9k]
| | | | ------------------
| | ------------------
| | 659| 10| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 10| do { \
| | | | 427| 10| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 10| return igraph_errno ; \
| | | | 429| 10| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 10| } \
| | 661| 20.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.9k]
| | ------------------
------------------
1786| |
1787| 19.9k| log = rec->value.as_vector_bool;
1788| 19.9k| if (igraph_es_is_all(&es)) {
------------------
| Branch (1788:9): [True: 18, False: 19.9k]
------------------
1789| 18| IGRAPH_CHECK(igraph_vector_bool_append(value, log));
------------------
| | 656| 18| do { \
| | 657| 18| igraph_error_t igraph_i_ret = (expr); \
| | 658| 18| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 18| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 18]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 18| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 18]
| | ------------------
------------------
1790| 19.9k| } else {
1791| 19.9k| igraph_eit_t it;
1792| 19.9k| igraph_int_t i = igraph_vector_bool_size(value);
1793| 19.9k| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 656| 19.9k| do { \
| | 657| 19.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.9k]
| | ------------------
------------------
1794| 19.9k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 19.9k| do { \
| | 604| 19.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 19.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 19.9k| * incorrect destructor function with the pointer */ \
| | 607| 19.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 19.9k]
| | ------------------
| | 608| 19.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 19.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 19.9k]
| | ------------------
------------------
1795| 19.9k| IGRAPH_CHECK(igraph_vector_bool_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 656| 19.9k| do { \
| | 657| 19.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.9k]
| | ------------------
------------------
1796| 39.9k| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 39.9k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 19.9k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1796:16): [True: 19.9k, False: 19.9k]
------------------
1797| 19.9k| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 19.9k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 19.9k, False: 0]
| | ------------------
| | 406| 19.9k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1798| 19.9k| VECTOR(*value)[i] = VECTOR(*log)[e];
------------------
| | 60| 19.9k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*log)[e];
------------------
| | 60| 19.9k|#define VECTOR(v) ((v).stor_begin)
------------------
1799| 19.9k| }
1800| 19.9k| igraph_eit_destroy(&it);
1801| 19.9k| IGRAPH_FINALLY_CLEAN(1);
1802| 19.9k| }
1803| |
1804| 19.9k| return IGRAPH_SUCCESS;
1805| 19.9k|}
cattributes.c:igraph_i_cattribute_find:
69| 1.63M|) {
70| 1.63M| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name);
71| 1.63M| igraph_attribute_record_t *rec;
72| |
73| 1.63M| if (index >= 0) {
------------------
| Branch (73:9): [True: 1.61M, False: 28.6k]
------------------
74| 1.61M| rec = igraph_attribute_record_list_get_ptr(attrs, index);
75| 1.61M| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) {
------------------
| Branch (75:13): [True: 1.61M, False: 0]
| Branch (75:53): [True: 0, False: 0]
------------------
76| 1.61M| return rec;
77| 1.61M| }
78| 1.61M| }
79| |
80| 28.6k| return NULL;
81| 1.63M|}
cattributes.c:igraph_i_cattribute_find_or_create:
147| 28.6k|) {
148| 28.6k| igraph_attribute_record_t *rec;
149| |
150| 28.6k| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED);
151| 28.6k| if (rec) {
------------------
| Branch (151:9): [True: 0, False: 28.6k]
------------------
152| 0| if (type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (152:13): [True: 0, False: 0]
------------------
153| 0| IGRAPH_CHECK(igraph_attribute_record_check_type(rec, type));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
154| 0| }
155| 28.6k| } else {
156| 28.6k| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(attrs, &rec));
------------------
| | 656| 28.6k| do { \
| | 657| 28.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 28.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 28.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 28.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 28.6k]
| | ------------------
------------------
157| 28.6k| IGRAPH_CHECK(igraph_attribute_record_set_name(rec, name));
------------------
| | 656| 28.6k| do { \
| | 657| 28.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 28.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 28.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 28.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 28.6k]
| | ------------------
------------------
158| 28.6k| IGRAPH_CHECK(igraph_attribute_record_set_type(rec, type));
------------------
| | 656| 28.6k| do { \
| | 657| 28.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 28.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 28.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 28.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 28.6k]
| | ------------------
------------------
159| 28.6k| }
160| |
161| 28.6k| if (length > 0 && igraph_attribute_record_size(rec) < length) {
------------------
| Branch (161:9): [True: 0, False: 28.6k]
| Branch (161:23): [True: 0, False: 0]
------------------
162| 0| IGRAPH_CHECK(igraph_attribute_record_resize(rec, length));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
163| 0| }
164| |
165| 28.6k| if (ptr) {
------------------
| Branch (165:9): [True: 0, False: 28.6k]
------------------
166| 0| *ptr = rec;
167| 0| }
168| |
169| 28.6k| return IGRAPH_SUCCESS;
170| 28.6k|}
cattributes.c:igraph_i_cattribute_find_index:
49| 1.87M|) {
50| 1.87M| igraph_int_t n = igraph_attribute_record_list_size(attrs);
51| 3.44M| for (igraph_int_t i = 0; i < n; i++) {
------------------
| Branch (51:30): [True: 3.21M, False: 236k]
------------------
52| 3.21M| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrs, i);
53| 3.21M| if (!strcmp(rec->name, name)) {
------------------
| Branch (53:13): [True: 1.64M, False: 1.56M]
------------------
54| 1.64M| return i;
55| 1.64M| }
56| 3.21M| }
57| 236k| return -1;
58| 1.87M|}
igraph_vss_all:
115| 1.35k|igraph_vs_t igraph_vss_all(void) {
116| 1.35k| igraph_vs_t allvs;
117| 1.35k| allvs.type = IGRAPH_VS_ALL;
118| 1.35k| return allvs;
119| 1.35k|}
igraph_vss_1:
292| 126k|igraph_vs_t igraph_vss_1(igraph_int_t vid) {
293| 126k| igraph_vs_t onevs;
294| 126k| onevs.type = IGRAPH_VS_1;
295| 126k| onevs.data.vid = vid;
296| 126k| return onevs;
297| 126k|}
igraph_vs_is_all:
544| 127k|igraph_bool_t igraph_vs_is_all(const igraph_vs_t *vs) {
545| 127k| return vs->type == IGRAPH_VS_ALL;
546| 127k|}
igraph_vit_create:
712| 126k|igraph_error_t igraph_vit_create(const igraph_t *graph, igraph_vs_t vs, igraph_vit_t *vit) {
713| 126k| igraph_vector_int_t vec;
714| 126k| igraph_vector_int_t *vec_int;
715| 126k| igraph_bool_t *seen;
716| 126k| igraph_int_t i, j, n;
717| 126k| igraph_int_t vec_len;
718| |
719| 126k| switch (vs.type) {
720| 0| case IGRAPH_VS_ALL:
------------------
| Branch (720:5): [True: 0, False: 126k]
------------------
721| 0| vit->type = IGRAPH_VIT_RANGE;
722| 0| vit->pos = 0;
723| 0| vit->start = 0;
724| 0| vit->end = igraph_vcount(graph);
725| 0| break;
726| 0| case IGRAPH_VS_ADJ:
------------------
| Branch (726:5): [True: 0, False: 126k]
------------------
727| 0| vec_int = IGRAPH_CALLOC(1, igraph_vector_int_t);
------------------
| | 33| 0|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 0| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 0, Folded]
| | | | ------------------
| | ------------------
------------------
728| 0| IGRAPH_CHECK_OOM(vec_int, "Cannot create vertex iterator.");
------------------
| | 709| 0| do { \
| | 710| 0| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 0| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 0]
| | ------------------
------------------
729| 0| IGRAPH_FINALLY(igraph_free, vec_int);
------------------
| | 603| 0| do { \
| | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 0| * incorrect destructor function with the pointer */ \
| | 607| 0| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 0]
| | ------------------
| | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 0| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 0]
| | ------------------
------------------
730| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(vec_int, 0);
------------------
| | 119| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 0| do { \
| | | | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 0| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 120| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 0| do { \
| | | | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 0| * incorrect destructor function with the pointer */ \
| | | | 607| 0| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 0]
| | | | ------------------
| | | | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 0| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 0]
| | ------------------
------------------
731| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vec, 0);
------------------
| | 119| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 0| do { \
| | | | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 0| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 120| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 0| do { \
| | | | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 0| * incorrect destructor function with the pointer */ \
| | | | 607| 0| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 0]
| | | | ------------------
| | | | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 0| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 0]
| | ------------------
------------------
732| 0| IGRAPH_CHECK(igraph_neighbors(
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
733| 0| graph, &vec, vs.data.adj.vid, vs.data.adj.mode,
734| 0| vs.data.adj.loops, vs.data.adj.multiple
735| 0| ));
736| 0| n = igraph_vector_int_size(&vec);
737| 0| IGRAPH_CHECK(igraph_vector_int_resize(vec_int, n));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
738| 0| for (i = 0; i < n; i++) {
------------------
| Branch (738:21): [True: 0, False: 0]
------------------
739| 0| VECTOR(*vec_int)[i] = VECTOR(vec)[i];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*vec_int)[i] = VECTOR(vec)[i];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
740| 0| }
741| |
742| 0| igraph_vector_int_destroy(&vec);
743| 0| IGRAPH_FINALLY_CLEAN(3);
744| |
745| 0| vit->type = IGRAPH_VIT_VECTOR;
746| 0| vit->pos = 0;
747| 0| vit->start = 0;
748| 0| vit->vec = vec_int;
749| 0| vit->end = n;
750| |
751| 0| break;
752| 0| case IGRAPH_VS_NONADJ:
------------------
| Branch (752:5): [True: 0, False: 126k]
------------------
753| 0| vec_int = IGRAPH_CALLOC(1, igraph_vector_int_t);
------------------
| | 33| 0|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 0| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 0, Folded]
| | | | ------------------
| | ------------------
------------------
754| 0| IGRAPH_CHECK_OOM(vec_int, "Cannot create vertex iterator.");
------------------
| | 709| 0| do { \
| | 710| 0| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 0| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 0]
| | ------------------
------------------
755| 0| IGRAPH_FINALLY(igraph_free, vec_int);
------------------
| | 603| 0| do { \
| | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 0| * incorrect destructor function with the pointer */ \
| | 607| 0| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 0]
| | ------------------
| | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 0| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 0]
| | ------------------
------------------
756| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(vec_int, 0);
------------------
| | 119| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 0| do { \
| | | | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 0| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 120| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 0| do { \
| | | | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 0| * incorrect destructor function with the pointer */ \
| | | | 607| 0| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 0]
| | | | ------------------
| | | | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 0| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 0]
| | ------------------
------------------
757| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vec, 0);
------------------
| | 119| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 0| do { \
| | | | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 0| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 120| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 0| do { \
| | | | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 0| * incorrect destructor function with the pointer */ \
| | | | 607| 0| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 0]
| | | | ------------------
| | | | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 0| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 0]
| | ------------------
------------------
758| 0| IGRAPH_CHECK(igraph_neighbors(
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
759| 0| graph, &vec, vs.data.adj.vid, vs.data.adj.mode,
760| 0| vs.data.adj.loops, vs.data.adj.multiple
761| 0| ));
762| 0| vec_len = igraph_vector_int_size(&vec);
763| 0| n = igraph_vcount(graph);
764| 0| seen = IGRAPH_CALLOC(n, igraph_bool_t);
------------------
| | 33| 0|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 0| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, False: 0]
| | | | | Branch (31:24): [True: 0, False: 0]
| | | | | Branch (31:66): [True: 0, False: 0]
| | | | ------------------
| | ------------------
------------------
765| 0| IGRAPH_CHECK_OOM(seen, "Cannot create vertex iterator.");
------------------
| | 709| 0| do { \
| | 710| 0| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 0| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 0]
| | ------------------
------------------
766| 0| IGRAPH_FINALLY(igraph_free, seen);
------------------
| | 603| 0| do { \
| | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 0| * incorrect destructor function with the pointer */ \
| | 607| 0| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 0]
| | ------------------
| | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 0| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 0]
| | ------------------
------------------
767| 0| for (i = 0; i < vec_len; i++) {
------------------
| Branch (767:21): [True: 0, False: 0]
------------------
768| 0| if (! seen [ VECTOR(vec)[i] ] ) {
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (768:17): [True: 0, False: 0]
------------------
769| 0| n--;
770| 0| seen[ VECTOR(vec)[i] ] = true;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
771| 0| }
772| 0| }
773| 0| IGRAPH_CHECK(igraph_vector_int_resize(vec_int, n));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
774| 0| for (i = 0, j = 0; j < n; i++) {
------------------
| Branch (774:28): [True: 0, False: 0]
------------------
775| 0| if (!seen[i]) {
------------------
| Branch (775:17): [True: 0, False: 0]
------------------
776| 0| VECTOR(*vec_int)[j++] = i;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
777| 0| }
778| 0| }
779| |
780| 0| IGRAPH_FREE(seen);
------------------
| | 36| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
781| 0| igraph_vector_int_destroy(&vec);
782| 0| IGRAPH_FINALLY_CLEAN(4);
783| |
784| 0| vit->type = IGRAPH_VIT_VECTOR;
785| 0| vit->pos = 0;
786| 0| vit->start = 0;
787| 0| vit->vec = vec_int;
788| 0| vit->end = n;
789| 0| break;
790| 0| case IGRAPH_VS_NONE:
------------------
| Branch (790:5): [True: 0, False: 126k]
------------------
791| 0| vit->type = IGRAPH_VIT_RANGE;
792| 0| vit->pos = 0;
793| 0| vit->start = 0;
794| 0| vit->end = 0;
795| 0| break;
796| 126k| case IGRAPH_VS_1:
------------------
| Branch (796:5): [True: 126k, False: 0]
------------------
797| 126k| vit->type = IGRAPH_VIT_RANGE;
798| 126k| vit->pos = vs.data.vid;
799| 126k| vit->start = vs.data.vid;
800| 126k| vit->end = vs.data.vid + 1;
801| 126k| if (vit->pos >= igraph_vcount(graph)) {
------------------
| Branch (801:13): [True: 0, False: 126k]
------------------
802| 0| IGRAPH_ERROR("Cannot create iterator, invalid vertex ID.", IGRAPH_EINVVID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
803| 0| }
804| 126k| break;
805| 126k| case IGRAPH_VS_VECTORPTR:
------------------
| Branch (805:5): [True: 0, False: 126k]
------------------
806| 0| case IGRAPH_VS_VECTOR:
------------------
| Branch (806:5): [True: 0, False: 126k]
------------------
807| 0| vit->type = IGRAPH_VIT_VECTORPTR;
808| 0| vit->pos = 0;
809| 0| vit->start = 0;
810| 0| vit->vec = vs.data.vecptr;
811| 0| vit->end = igraph_vector_int_size(vit->vec);
812| 0| if (!igraph_vector_int_isininterval(vit->vec, 0, igraph_vcount(graph) - 1)) {
------------------
| Branch (812:13): [True: 0, False: 0]
------------------
813| 0| IGRAPH_ERROR("Cannot create iterator, invalid vertex ID.", IGRAPH_EINVVID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
814| 0| }
815| 0| break;
816| 0| case IGRAPH_VS_RANGE:
------------------
| Branch (816:5): [True: 0, False: 126k]
------------------
817| 0| {
818| 0| igraph_int_t no_of_nodes = igraph_vcount(graph);
819| 0| if (vs.data.range.start < 0 ||
------------------
| Branch (819:17): [True: 0, False: 0]
------------------
820| 0| vs.data.range.start > no_of_nodes ||
------------------
| Branch (820:17): [True: 0, False: 0]
------------------
821| 0| (no_of_nodes > 0 && vs.data.range.start == no_of_nodes)) {
------------------
| Branch (821:18): [True: 0, False: 0]
| Branch (821:37): [True: 0, False: 0]
------------------
822| 0| IGRAPH_ERROR("Cannot create range iterator, starting vertex ID out of range.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
823| 0| }
824| 0| if (vs.data.range.end < 0 || vs.data.range.end > no_of_nodes) {
------------------
| Branch (824:17): [True: 0, False: 0]
| Branch (824:42): [True: 0, False: 0]
------------------
825| 0| IGRAPH_ERROR("Cannot create range iterator, ending vertex ID out of range.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
826| 0| }
827| 0| }
828| 0| vit->type = IGRAPH_VIT_RANGE;
829| 0| vit->pos = vs.data.range.start;
830| 0| vit->start = vs.data.range.start;
831| 0| vit->end = vs.data.range.end;
832| 0| break;
833| 0| default:
------------------
| Branch (833:5): [True: 0, False: 126k]
------------------
834| 0| IGRAPH_ERROR("Cannot create iterator, invalid selector.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
835| 0| break;
836| 126k| }
837| 126k| return IGRAPH_SUCCESS;
838| 126k|}
igraph_vit_destroy:
853| 126k|void igraph_vit_destroy(const igraph_vit_t *vit) {
854| 126k| switch (vit->type) {
855| 126k| case IGRAPH_VIT_RANGE:
------------------
| Branch (855:5): [True: 126k, False: 0]
------------------
856| 126k| case IGRAPH_VIT_VECTORPTR:
------------------
| Branch (856:5): [True: 0, False: 126k]
------------------
857| 126k| break;
858| 0| case IGRAPH_VIT_VECTOR:
------------------
| Branch (858:5): [True: 0, False: 126k]
------------------
859| 0| igraph_vector_int_destroy((igraph_vector_int_t*) vit->vec);
860| 0| igraph_free((igraph_vector_int_t*) vit->vec);
861| 0| break;
862| 0| default:
------------------
| Branch (862:5): [True: 0, False: 126k]
------------------
863| | /* IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */
864| 0| break;
865| 126k| }
866| 126k|}
igraph_es_all:
921| 17.3k| igraph_edgeorder_type_t order) {
922| 17.3k| switch (order) {
923| 10.6k| case IGRAPH_EDGEORDER_ID:
------------------
| Branch (923:5): [True: 10.6k, False: 6.68k]
------------------
924| 10.6k| es->type = IGRAPH_ES_ALL;
925| 10.6k| break;
926| 6.68k| case IGRAPH_EDGEORDER_FROM:
------------------
| Branch (926:5): [True: 6.68k, False: 10.6k]
------------------
927| 6.68k| es->type = IGRAPH_ES_ALLFROM;
928| 6.68k| break;
929| 0| case IGRAPH_EDGEORDER_TO:
------------------
| Branch (929:5): [True: 0, False: 17.3k]
------------------
930| 0| es->type = IGRAPH_ES_ALLTO;
931| 0| break;
932| 0| default:
------------------
| Branch (932:5): [True: 0, False: 17.3k]
------------------
933| 0| IGRAPH_ERROR("Invalid edge order, cannot create selector.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
934| 0| break;
935| 17.3k| }
936| 17.3k| return IGRAPH_SUCCESS;
937| 17.3k|}
igraph_ess_all:
953| 13.9k|igraph_es_t igraph_ess_all(igraph_edgeorder_type_t order) {
954| 13.9k| igraph_es_t es;
955| 13.9k| igraph_es_all(&es, order); /* cannot fail */
956| 13.9k| return es;
957| 13.9k|}
igraph_ess_1:
1058| 1.47M|igraph_es_t igraph_ess_1(igraph_int_t eid) {
1059| 1.47M| igraph_es_t es;
1060| 1.47M| es.type = IGRAPH_ES_1;
1061| 1.47M| es.data.eid = eid;
1062| 1.47M| return es;
1063| 1.47M|}
igraph_es_destroy:
1408| 3.34k|void igraph_es_destroy(igraph_es_t *es) {
1409| 3.34k| switch (es->type) {
1410| 3.34k| case IGRAPH_ES_ALL:
------------------
| Branch (1410:5): [True: 3.34k, False: 0]
------------------
1411| 3.34k| case IGRAPH_ES_ALLFROM:
------------------
| Branch (1411:5): [True: 0, False: 3.34k]
------------------
1412| 3.34k| case IGRAPH_ES_ALLTO:
------------------
| Branch (1412:5): [True: 0, False: 3.34k]
------------------
1413| 3.34k| case IGRAPH_ES_INCIDENT:
------------------
| Branch (1413:5): [True: 0, False: 3.34k]
------------------
1414| 3.34k| case IGRAPH_ES_NONE:
------------------
| Branch (1414:5): [True: 0, False: 3.34k]
------------------
1415| 3.34k| case IGRAPH_ES_1:
------------------
| Branch (1415:5): [True: 0, False: 3.34k]
------------------
1416| 3.34k| case IGRAPH_ES_VECTORPTR:
------------------
| Branch (1416:5): [True: 0, False: 3.34k]
------------------
1417| 3.34k| case IGRAPH_ES_RANGE:
------------------
| Branch (1417:5): [True: 0, False: 3.34k]
------------------
1418| 3.34k| case IGRAPH_ES_ALL_BETWEEN:
------------------
| Branch (1418:5): [True: 0, False: 3.34k]
------------------
1419| 3.34k| break;
1420| 0| case IGRAPH_ES_VECTOR:
------------------
| Branch (1420:5): [True: 0, False: 3.34k]
------------------
1421| 0| igraph_vector_int_destroy((igraph_vector_int_t*)es->data.vecptr);
1422| 0| IGRAPH_FREE(es->data.vecptr);
------------------
| | 36| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1423| 0| break;
1424| 0| case IGRAPH_ES_PAIRS:
------------------
| Branch (1424:5): [True: 0, False: 3.34k]
------------------
1425| 0| case IGRAPH_ES_PATH:
------------------
| Branch (1425:5): [True: 0, False: 3.34k]
------------------
1426| 0| igraph_vector_int_destroy((igraph_vector_int_t*)es->data.path.ptr);
1427| 0| IGRAPH_FREE(es->data.path.ptr);
------------------
| | 36| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1428| 0| break;
1429| 0| default:
------------------
| Branch (1429:5): [True: 0, False: 3.34k]
------------------
1430| 0| break;
1431| 3.34k| }
1432| 3.34k|}
igraph_es_is_all:
1445| 1.47M|igraph_bool_t igraph_es_is_all(const igraph_es_t *es) {
1446| 1.47M| return es->type == IGRAPH_ES_ALL;
1447| 1.47M|}
igraph_eit_create:
1922| 1.49M|igraph_error_t igraph_eit_create(const igraph_t *graph, igraph_es_t es, igraph_eit_t *eit) {
1923| 1.49M| switch (es.type) {
1924| 10.0k| case IGRAPH_ES_ALL:
------------------
| Branch (1924:5): [True: 10.0k, False: 1.48M]
------------------
1925| 10.0k| eit->type = IGRAPH_EIT_RANGE;
1926| 10.0k| eit->pos = 0;
1927| 10.0k| eit->start = 0;
1928| 10.0k| eit->end = igraph_ecount(graph);
1929| 10.0k| break;
1930| 6.68k| case IGRAPH_ES_ALLFROM:
------------------
| Branch (1930:5): [True: 6.68k, False: 1.48M]
------------------
1931| 6.68k| IGRAPH_CHECK(igraph_i_eit_create_allfromto(graph, eit, IGRAPH_OUT));
------------------
| | 656| 6.68k| do { \
| | 657| 6.68k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.68k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.68k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.68k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.68k]
| | ------------------
------------------
1932| 6.68k| break;
1933| 6.68k| case IGRAPH_ES_ALLTO:
------------------
| Branch (1933:5): [True: 0, False: 1.49M]
------------------
1934| 0| IGRAPH_CHECK(igraph_i_eit_create_allfromto(graph, eit, IGRAPH_IN));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
1935| 0| break;
1936| 0| case IGRAPH_ES_INCIDENT:
------------------
| Branch (1936:5): [True: 0, False: 1.49M]
------------------
1937| 0| IGRAPH_CHECK(igraph_i_eit_create_incident(graph, es, eit));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
1938| 0| break;
1939| 0| case IGRAPH_ES_NONE:
------------------
| Branch (1939:5): [True: 0, False: 1.49M]
------------------
1940| 0| eit->type = IGRAPH_EIT_RANGE;
1941| 0| eit->pos = 0;
1942| 0| eit->start = 0;
1943| 0| eit->end = 0;
1944| 0| break;
1945| 1.47M| case IGRAPH_ES_1:
------------------
| Branch (1945:5): [True: 1.47M, False: 16.7k]
------------------
1946| 1.47M| eit->type = IGRAPH_EIT_RANGE;
1947| 1.47M| eit->pos = es.data.eid;
1948| 1.47M| eit->start = es.data.eid;
1949| 1.47M| eit->end = es.data.eid + 1;
1950| 1.47M| if (eit->pos >= igraph_ecount(graph)) {
------------------
| Branch (1950:13): [True: 0, False: 1.47M]
------------------
1951| 0| IGRAPH_ERROR("Cannot create iterator.", IGRAPH_EINVEID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1952| 0| }
1953| 1.47M| break;
1954| 1.47M| case IGRAPH_ES_VECTOR:
------------------
| Branch (1954:5): [True: 0, False: 1.49M]
------------------
1955| 0| case IGRAPH_ES_VECTORPTR:
------------------
| Branch (1955:5): [True: 0, False: 1.49M]
------------------
1956| 0| eit->type = IGRAPH_EIT_VECTORPTR;
1957| 0| eit->pos = 0;
1958| 0| eit->start = 0;
1959| 0| eit->vec = es.data.vecptr;
1960| 0| eit->end = igraph_vector_int_size(eit->vec);
1961| 0| if (!igraph_vector_int_isininterval(eit->vec, 0, igraph_ecount(graph) - 1)) {
------------------
| Branch (1961:13): [True: 0, False: 0]
------------------
1962| 0| IGRAPH_ERROR("Cannot create iterator.", IGRAPH_EINVEID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1963| 0| }
1964| 0| break;
1965| 0| case IGRAPH_ES_RANGE:
------------------
| Branch (1965:5): [True: 0, False: 1.49M]
------------------
1966| 0| {
1967| 0| igraph_int_t no_of_edges = igraph_ecount(graph);
1968| 0| if (es.data.range.start < 0 ||
------------------
| Branch (1968:17): [True: 0, False: 0]
------------------
1969| 0| es.data.range.start > no_of_edges ||
------------------
| Branch (1969:17): [True: 0, False: 0]
------------------
1970| 0| (no_of_edges > 0 && es.data.range.start == no_of_edges)) {
------------------
| Branch (1970:18): [True: 0, False: 0]
| Branch (1970:37): [True: 0, False: 0]
------------------
1971| 0| IGRAPH_ERROR("Cannot create range iterator, starting edge ID out of range.", IGRAPH_EINVEID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1972| 0| }
1973| 0| if (es.data.range.end < 0 || es.data.range.end > no_of_edges) {
------------------
| Branch (1973:17): [True: 0, False: 0]
| Branch (1973:42): [True: 0, False: 0]
------------------
1974| 0| IGRAPH_ERROR("Cannot create range iterator, ending edge ID out of range.", IGRAPH_EINVEID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1975| 0| }
1976| 0| }
1977| 0| eit->type = IGRAPH_EIT_RANGE;
1978| 0| eit->pos = es.data.range.start;
1979| 0| eit->start = es.data.range.start;
1980| 0| eit->end = es.data.range.end;
1981| 0| break;
1982| 0| case IGRAPH_ES_PAIRS:
------------------
| Branch (1982:5): [True: 0, False: 1.49M]
------------------
1983| 0| IGRAPH_CHECK(igraph_i_eit_pairs(graph, es, eit));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
1984| 0| break;
1985| 0| case IGRAPH_ES_PATH:
------------------
| Branch (1985:5): [True: 0, False: 1.49M]
------------------
1986| 0| IGRAPH_CHECK(igraph_i_eit_path(graph, es, eit));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
1987| 0| break;
1988| 0| case IGRAPH_ES_ALL_BETWEEN:
------------------
| Branch (1988:5): [True: 0, False: 1.49M]
------------------
1989| 0| IGRAPH_CHECK(igraph_i_eit_all_between(graph, es, eit));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
1990| 0| break;
1991| 0| default:
------------------
| Branch (1991:5): [True: 0, False: 1.49M]
------------------
1992| 0| IGRAPH_ERROR("Cannot create iterator, invalid selector.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1993| 0| break;
1994| 1.49M| }
1995| 1.49M| return IGRAPH_SUCCESS;
1996| 1.49M|}
igraph_eit_destroy:
2008| 1.49M|void igraph_eit_destroy(const igraph_eit_t *eit) {
2009| 1.49M| switch (eit->type) {
2010| 1.48M| case IGRAPH_EIT_RANGE:
------------------
| Branch (2010:5): [True: 1.48M, False: 6.68k]
------------------
2011| 1.48M| case IGRAPH_EIT_VECTORPTR:
------------------
| Branch (2011:5): [True: 0, False: 1.49M]
------------------
2012| 1.48M| break;
2013| 6.68k| case IGRAPH_EIT_VECTOR:
------------------
| Branch (2013:5): [True: 6.68k, False: 1.48M]
------------------
2014| 6.68k| igraph_vector_int_destroy((igraph_vector_int_t*)eit->vec);
2015| 6.68k| igraph_free((igraph_vector_int_t*)eit->vec);
2016| 6.68k| break;
2017| 0| default:
------------------
| Branch (2017:5): [True: 0, False: 1.49M]
------------------
2018| | /* IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */
2019| 0| break;
2020| 1.49M| }
2021| 1.49M|}
iterators.c:igraph_i_eit_create_allfromto:
1696| 6.68k| igraph_neimode_t mode) {
1697| 6.68k| igraph_vector_int_t *vec;
1698| 6.68k| igraph_int_t no_of_nodes = igraph_vcount(graph);
1699| 6.68k| igraph_int_t no_of_edges = igraph_ecount(graph);
1700| |
1701| 6.68k| vec = IGRAPH_CALLOC(1, igraph_vector_int_t);
------------------
| | 33| 6.68k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 13.3k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 6.68k, Folded]
| | | | ------------------
| | ------------------
------------------
1702| 6.68k| IGRAPH_CHECK_OOM(vec, "Cannot create edge iterator.");
------------------
| | 709| 6.68k| do { \
| | 710| 6.68k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 6.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.68k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 6.68k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 6.68k]
| | ------------------
------------------
1703| 6.68k| IGRAPH_FINALLY(igraph_free, vec);
------------------
| | 603| 6.68k| do { \
| | 604| 6.68k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.68k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.68k| * incorrect destructor function with the pointer */ \
| | 607| 6.68k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.68k]
| | ------------------
| | 608| 6.68k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.68k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.68k]
| | ------------------
------------------
1704| |
1705| 6.68k| IGRAPH_VECTOR_INT_INIT_FINALLY(vec, 0);
------------------
| | 119| 6.68k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 6.68k| do { \
| | | | 657| 6.68k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 6.68k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 6.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 6.68k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 6.68k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 6.68k]
| | | | ------------------
| | ------------------
| | 120| 6.68k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 6.68k| do { \
| | | | 604| 6.68k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 6.68k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 6.68k| * incorrect destructor function with the pointer */ \
| | | | 607| 6.68k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 6.68k]
| | | | ------------------
| | | | 608| 6.68k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 6.68k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 6.68k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 6.68k]
| | ------------------
------------------
1706| 6.68k| IGRAPH_CHECK(igraph_vector_int_reserve(vec, no_of_edges));
------------------
| | 656| 6.68k| do { \
| | 657| 6.68k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.68k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.68k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.68k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.68k]
| | ------------------
------------------
1707| |
1708| 6.68k| if (igraph_is_directed(graph)) {
------------------
| Branch (1708:9): [True: 274, False: 6.40k]
------------------
1709| 274| igraph_vector_int_t adj;
1710| 274| IGRAPH_VECTOR_INT_INIT_FINALLY(&adj, 0);
------------------
| | 119| 274| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 274| do { \
| | | | 657| 274| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 274| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 274| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 274]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 274| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 274]
| | | | ------------------
| | ------------------
| | 120| 274| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 274| do { \
| | | | 604| 274| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 274| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 274| * incorrect destructor function with the pointer */ \
| | | | 607| 274| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 274]
| | | | ------------------
| | | | 608| 274| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 274| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 274]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 274]
| | ------------------
------------------
1711| 2.67k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1711:34): [True: 2.40k, False: 274]
------------------
1712| 2.40k| IGRAPH_CHECK(igraph_incident(graph, &adj, i, mode, IGRAPH_LOOPS));
------------------
| | 656| 2.40k| do { \
| | 657| 2.40k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.40k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.40k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.40k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.40k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.40k]
| | ------------------
------------------
1713| 2.40k| igraph_vector_int_append(vec, &adj); /* reserved */
1714| 2.40k| }
1715| 274| igraph_vector_int_destroy(&adj);
1716| 274| IGRAPH_FINALLY_CLEAN(1);
1717| 6.40k| } else {
1718| 6.40k| igraph_vector_int_t adj;
1719| 6.40k| igraph_bool_t *added;
1720| 6.40k| IGRAPH_VECTOR_INT_INIT_FINALLY(&adj, 0);
------------------
| | 119| 6.40k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 6.40k| do { \
| | | | 657| 6.40k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 6.40k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 6.40k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 6.40k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 6.40k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 6.40k]
| | | | ------------------
| | ------------------
| | 120| 6.40k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 6.40k| do { \
| | | | 604| 6.40k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 6.40k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 6.40k| * incorrect destructor function with the pointer */ \
| | | | 607| 6.40k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 6.40k]
| | | | ------------------
| | | | 608| 6.40k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 6.40k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 6.40k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 6.40k]
| | ------------------
------------------
1721| 6.40k| added = IGRAPH_CALLOC(no_of_edges, igraph_bool_t);
------------------
| | 33| 6.40k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 12.8k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 6.40k, False: 0]
| | | | | Branch (31:24): [True: 6.40k, False: 0]
| | | | | Branch (31:66): [True: 4.63k, False: 1.77k]
| | | | ------------------
| | ------------------
------------------
1722| 6.40k| IGRAPH_CHECK_OOM(added, "Cannot create edge iterator.");
------------------
| | 709| 6.40k| do { \
| | 710| 6.40k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 6.40k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.40k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 6.40k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 6.40k]
| | ------------------
------------------
1723| 6.40k| IGRAPH_FINALLY(igraph_free, added);
------------------
| | 603| 6.40k| do { \
| | 604| 6.40k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.40k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.40k| * incorrect destructor function with the pointer */ \
| | 607| 6.40k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.40k]
| | ------------------
| | 608| 6.40k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.40k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.40k]
| | ------------------
------------------
1724| 70.9k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1724:34): [True: 64.5k, False: 6.40k]
------------------
1725| 64.5k| IGRAPH_CHECK(igraph_incident(graph, &adj, i, IGRAPH_ALL, IGRAPH_LOOPS));
------------------
| | 656| 64.5k| do { \
| | 657| 64.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 64.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 64.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 64.5k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 64.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 64.5k]
| | ------------------
------------------
1726| 64.5k| const igraph_int_t length = igraph_vector_int_size(&adj);
1727| 966k| for (igraph_int_t j = 0; j < length; j++) {
------------------
| Branch (1727:38): [True: 902k, False: 64.5k]
------------------
1728| 902k| if (!added[ VECTOR(adj)[j] ]) {
------------------
| | 60| 902k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1728:21): [True: 451k, False: 451k]
------------------
1729| 451k| igraph_vector_int_push_back(vec, VECTOR(adj)[j]); /* reserved */
------------------
| | 60| 451k|#define VECTOR(v) ((v).stor_begin)
------------------
1730| 451k| added[ VECTOR(adj)[j] ] = true;
------------------
| | 60| 451k|#define VECTOR(v) ((v).stor_begin)
------------------
1731| 451k| }
1732| 902k| }
1733| 64.5k| }
1734| 6.40k| igraph_vector_int_destroy(&adj);
1735| 6.40k| IGRAPH_FREE(added);
------------------
| | 36| 6.40k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1736| 6.40k| IGRAPH_FINALLY_CLEAN(2);
1737| 6.40k| }
1738| |
1739| 6.68k| eit->type = IGRAPH_EIT_VECTOR;
1740| 6.68k| eit->pos = 0;
1741| 6.68k| eit->start = 0;
1742| 6.68k| eit->vec = vec;
1743| 6.68k| eit->end = igraph_vector_int_size(eit->vec);
1744| |
1745| 6.68k| IGRAPH_FINALLY_CLEAN(2);
1746| 6.68k| return IGRAPH_SUCCESS;
1747| 6.68k|}
igraph_empty:
64| 6.44k|igraph_error_t igraph_empty(igraph_t *graph, igraph_int_t n, igraph_bool_t directed) {
65| 6.44k| return igraph_empty_attrs(graph, n, directed, 0);
66| 6.44k|}
igraph_edge:
132| 1.72M|) {
133| |
134| 1.72M| if (eid < 0 || eid >= igraph_ecount(graph)) {
------------------
| Branch (134:9): [True: 0, False: 1.72M]
| Branch (134:20): [True: 0, False: 1.72M]
------------------
135| 0| IGRAPH_ERROR("Cannot retrieve edge endpoints.", IGRAPH_EINVEID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
136| 0| }
137| |
138| 1.72M| if (igraph_is_directed(graph)) {
------------------
| Branch (138:9): [True: 597k, False: 1.12M]
------------------
139| 597k| *from = IGRAPH_FROM(graph, eid);
------------------
| | 115| 597k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 597k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
140| 597k| *to = IGRAPH_TO(graph, eid);
------------------
| | 128| 597k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 597k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
141| 1.12M| } else {
142| 1.12M| *from = IGRAPH_TO(graph, eid);
------------------
| | 128| 1.12M|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 1.12M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
143| 1.12M| *to = IGRAPH_FROM(graph, eid);
------------------
| | 115| 1.12M|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 1.12M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
144| 1.12M| }
145| |
146| 1.72M| return IGRAPH_SUCCESS;
147| 1.72M|}
igraph_empty_attrs:
102| 16.4k|) {
103| |
104| 16.4k| if (n < 0) {
------------------
| Branch (104:9): [True: 0, False: 16.4k]
------------------
105| 0| IGRAPH_ERROR("Number of vertices must not be negative.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
106| 0| }
107| |
108| 16.4k| memset(graph, 0, sizeof(igraph_t));
109| |
110| 16.4k| graph->n = 0;
111| 16.4k| graph->directed = directed;
112| 16.4k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0);
------------------
| | 119| 16.4k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 16.4k| do { \
| | | | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | 120| 16.4k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 16.4k| do { \
| | | | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | | | 607| 16.4k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 16.4k]
| | | | ------------------
| | | | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 16.4k]
| | ------------------
------------------
113| 16.4k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0);
------------------
| | 119| 16.4k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 16.4k| do { \
| | | | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | 120| 16.4k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 16.4k| do { \
| | | | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | | | 607| 16.4k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 16.4k]
| | | | ------------------
| | | | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 16.4k]
| | ------------------
------------------
114| 16.4k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0);
------------------
| | 119| 16.4k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 16.4k| do { \
| | | | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | 120| 16.4k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 16.4k| do { \
| | | | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | | | 607| 16.4k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 16.4k]
| | | | ------------------
| | | | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 16.4k]
| | ------------------
------------------
115| 16.4k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0);
------------------
| | 119| 16.4k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 16.4k| do { \
| | | | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | 120| 16.4k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 16.4k| do { \
| | | | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | | | 607| 16.4k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 16.4k]
| | | | ------------------
| | | | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 16.4k]
| | ------------------
------------------
116| 16.4k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1);
------------------
| | 119| 16.4k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 16.4k| do { \
| | | | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | 120| 16.4k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 16.4k| do { \
| | | | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | | | 607| 16.4k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 16.4k]
| | | | ------------------
| | | | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 16.4k]
| | ------------------
------------------
117| 16.4k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1);
------------------
| | 119| 16.4k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 16.4k| do { \
| | | | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | 120| 16.4k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 16.4k| do { \
| | | | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | | | 607| 16.4k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 16.4k]
| | | | ------------------
| | | | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 16.4k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 16.4k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 16.4k]
| | ------------------
------------------
118| |
119| | /* init cache */
120| 16.4k| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t);
------------------
| | 33| 16.4k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 32.8k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 16.4k, Folded]
| | | | ------------------
| | ------------------
------------------
121| 16.4k| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph.");
------------------
| | 709| 16.4k| do { \
| | 710| 16.4k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 16.4k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 16.4k]
| | ------------------
------------------
122| 16.4k| IGRAPH_FINALLY(igraph_free, graph->cache);
------------------
| | 603| 16.4k| do { \
| | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | 607| 16.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.4k]
| | ------------------
| | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.4k]
| | ------------------
------------------
123| 16.4k| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache));
------------------
| | 656| 16.4k| do { \
| | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 16.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.4k]
| | ------------------
------------------
124| 16.4k| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache);
------------------
| | 603| 16.4k| do { \
| | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | 607| 16.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.4k]
| | ------------------
| | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.4k]
| | ------------------
------------------
125| |
126| 16.4k| VECTOR(graph->os)[0] = 0;
------------------
| | 60| 16.4k|#define VECTOR(v) ((v).stor_begin)
------------------
127| 16.4k| VECTOR(graph->is)[0] = 0;
------------------
| | 60| 16.4k|#define VECTOR(v) ((v).stor_begin)
------------------
128| |
129| | /* init attributes */
130| 16.4k| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr));
------------------
| | 656| 16.4k| do { \
| | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 16.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.4k]
| | ------------------
------------------
131| |
132| | /* add the vertices */
133| 16.4k| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0));
------------------
| | 656| 16.4k| do { \
| | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 16.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.4k]
| | ------------------
------------------
134| |
135| 16.4k| IGRAPH_FINALLY_CLEAN(8);
136| 16.4k| return IGRAPH_SUCCESS;
137| 16.4k|}
igraph_destroy:
155| 16.4k|void igraph_destroy(igraph_t *graph) {
156| 16.4k| igraph_i_attribute_destroy(graph);
157| |
158| 16.4k| igraph_i_property_cache_destroy(graph->cache);
159| 16.4k| IGRAPH_FREE(graph->cache);
------------------
| | 36| 16.4k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
160| |
161| 16.4k| igraph_vector_int_destroy(&graph->from);
162| 16.4k| igraph_vector_int_destroy(&graph->to);
163| 16.4k| igraph_vector_int_destroy(&graph->oi);
164| 16.4k| igraph_vector_int_destroy(&graph->ii);
165| 16.4k| igraph_vector_int_destroy(&graph->os);
166| 16.4k| igraph_vector_int_destroy(&graph->is);
167| 16.4k|}
igraph_add_edges:
257| 16.4k|) {
258| 16.4k| igraph_int_t no_of_edges = igraph_vector_int_size(&graph->from);
259| 16.4k| igraph_int_t edges_to_add = igraph_vector_int_size(edges) / 2;
260| 16.4k| igraph_int_t new_no_of_edges;
261| 16.4k| igraph_int_t i = 0;
262| 16.4k| igraph_vector_int_t newoi, newii;
263| 16.4k| igraph_bool_t directed = igraph_is_directed(graph);
264| |
265| 16.4k| if (igraph_vector_int_size(edges) % 2 != 0) {
------------------
| Branch (265:9): [True: 0, False: 16.4k]
------------------
266| 0| IGRAPH_ERROR("Invalid (odd) length of edges vector.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
267| 0| }
268| 16.4k| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) {
------------------
| Branch (268:9): [True: 0, False: 16.4k]
------------------
269| 0| IGRAPH_ERROR("Out-of-range vertex IDs when adding edges.", IGRAPH_EINVVID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
270| 0| }
271| |
272| | /* from & to */
273| 16.4k| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges);
------------------
| | 47| 16.4k| do { \
| | 48| 16.4k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 16.4k| igraph_int_t _safe_sum; \
| | 50| 16.4k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 16.4k]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 16.4k| *(res) = _safe_sum; \
| | 54| 16.4k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 16.4k]
| | ------------------
------------------
274| 16.4k| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) {
------------------
| | 118| 16.4k|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2)
| | ------------------
| | | | 72| 16.4k|# define IGRAPH_INTEGER_MAX INT64_MAX
| | ------------------
------------------
| Branch (274:9): [True: 0, False: 16.4k]
------------------
275| 0| IGRAPH_ERRORF("Maximum edge count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
276| 0| IGRAPH_ECOUNT_MAX);
277| 0| }
278| 16.4k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add));
------------------
| | 656| 16.4k| do { \
| | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 16.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.4k]
| | ------------------
------------------
279| 16.4k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add));
------------------
| | 656| 16.4k| do { \
| | 657| 16.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 16.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.4k]
| | ------------------
------------------
280| |
281| 1.73M| while (i < edges_to_add * 2) {
------------------
| Branch (281:12): [True: 1.72M, False: 16.4k]
------------------
282| 1.72M| if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) {
------------------
| | 60| 676k|#define VECTOR(v) ((v).stor_begin)
------------------
if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) {
------------------
| | 60| 676k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (282:13): [True: 1.04M, False: 676k]
| Branch (282:25): [True: 240k, False: 435k]
------------------
283| 1.28M| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 1.28M|#define VECTOR(v) ((v).stor_begin)
------------------
284| 1.28M| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 1.28M|#define VECTOR(v) ((v).stor_begin)
------------------
285| 1.28M| } else {
286| 435k| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 435k|#define VECTOR(v) ((v).stor_begin)
------------------
287| 435k| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 435k|#define VECTOR(v) ((v).stor_begin)
------------------
288| 435k| }
289| 1.72M| }
290| |
291| | /* If an error occurs while the edges are being added, we make the necessary fixup
292| | * to ensure that the graph is still in a consistent state when this function returns.
293| | * The graph may already be on the finally stack when calling this function. We use
294| | * a separate finally stack level to avoid its destructor from being called on error,
295| | * so that the fixup can succeed.
296| | */
297| |
298| 16.4k|#define CHECK_ERR(expr) \
299| 16.4k| do { \
300| 16.4k| igraph_error_t err = (expr); \
301| 16.4k| if (err != IGRAPH_SUCCESS) { \
302| 16.4k| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \
303| 16.4k| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \
304| 16.4k| IGRAPH_FINALLY_EXIT(); \
305| 16.4k| IGRAPH_ERROR("Cannot add edges.", err); \
306| 16.4k| } \
307| 16.4k| } while (0)
308| |
309| | /* oi & ii */
310| 16.4k| IGRAPH_FINALLY_ENTER();
311| 16.4k| {
312| 16.4k| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges));
------------------
| | 299| 16.4k| do { \
| | 300| 16.4k| igraph_error_t err = (expr); \
| | 301| 16.4k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 16.4k]
| | ------------------
| | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \
| | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \
| | 304| 0| IGRAPH_FINALLY_EXIT(); \
| | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 306| 0| } \
| | 307| 16.4k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 16.4k]
| | ------------------
------------------
313| 16.4k| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi);
------------------
| | 603| 16.4k| do { \
| | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | 607| 16.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.4k]
| | ------------------
| | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.4k]
| | ------------------
------------------
314| 16.4k| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges));
------------------
| | 299| 16.4k| do { \
| | 300| 16.4k| igraph_error_t err = (expr); \
| | 301| 16.4k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 16.4k]
| | ------------------
| | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \
| | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \
| | 304| 0| IGRAPH_FINALLY_EXIT(); \
| | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 306| 0| } \
| | 307| 16.4k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 16.4k]
| | ------------------
------------------
315| 16.4k| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii);
------------------
| | 603| 16.4k| do { \
| | 604| 16.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.4k| * incorrect destructor function with the pointer */ \
| | 607| 16.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.4k]
| | ------------------
| | 608| 16.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.4k]
| | ------------------
------------------
316| 16.4k| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n));
------------------
| | 299| 16.4k| do { \
| | 300| 16.4k| igraph_error_t err = (expr); \
| | 301| 16.4k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 16.4k]
| | ------------------
| | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \
| | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \
| | 304| 0| IGRAPH_FINALLY_EXIT(); \
| | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 306| 0| } \
| | 307| 16.4k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 16.4k]
| | ------------------
------------------
317| 16.4k| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n));
------------------
| | 299| 16.4k| do { \
| | 300| 16.4k| igraph_error_t err = (expr); \
| | 301| 16.4k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 16.4k]
| | ------------------
| | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \
| | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \
| | 304| 0| IGRAPH_FINALLY_EXIT(); \
| | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 306| 0| } \
| | 307| 16.4k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 16.4k]
| | ------------------
------------------
318| |
319| | /* Attributes */
320| 16.4k| if (graph->attr) {
------------------
| Branch (320:13): [True: 16.4k, False: 0]
------------------
321| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */
322| 16.4k| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr));
------------------
| | 299| 16.4k| do { \
| | 300| 16.4k| igraph_error_t err = (expr); \
| | 301| 16.4k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 16.4k]
| | ------------------
| | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \
| | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \
| | 304| 0| IGRAPH_FINALLY_EXIT(); \
| | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 306| 0| } \
| | 307| 16.4k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 16.4k]
| | ------------------
------------------
323| 16.4k| }
324| |
325| | /* os & is, its length does not change, error safe */
326| 16.4k| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n);
327| 16.4k| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n);
328| |
329| | /* everything went fine */
330| 16.4k| igraph_vector_int_destroy(&graph->oi);
331| 16.4k| igraph_vector_int_destroy(&graph->ii);
332| 16.4k| IGRAPH_FINALLY_CLEAN(2);
333| |
334| 16.4k| graph->oi = newoi;
335| 16.4k| graph->ii = newii;
336| 16.4k| }
337| 0| IGRAPH_FINALLY_EXIT();
338| |
339| 16.4k|#undef CHECK_ERR
340| |
341| | /* modification successful, clear the cached properties of the graph.
342| | *
343| | * Adding one or more edges cannot make a strongly or weakly connected
344| | * graph disconnected, so we keep those flags if they are cached as true.
345| | *
346| | * Adding one or more edges may turn a DAG into a non-DAG or a forest into
347| | * a non-forest, so we can keep those flags only if they are cached as
348| | * false.
349| | *
350| | * Also, adding one or more edges does not change HAS_LOOP, HAS_MULTI and
351| | * HAS_MUTUAL if they were already true.
352| | */
353| 16.4k| igraph_i_property_cache_invalidate_conditionally(
354| 16.4k| graph,
355| 16.4k| /* keep_always = */ 0,
356| | /* keep_when_false = */
357| 16.4k| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST),
358| | /* keep_when_true = */
359| 16.4k| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) |
360| 16.4k| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) |
361| 16.4k| (1 << IGRAPH_PROP_HAS_LOOP) |
362| 16.4k| (1 << IGRAPH_PROP_HAS_MULTI) |
363| 16.4k| (1 << IGRAPH_PROP_HAS_MUTUAL)
364| 16.4k| );
365| |
366| 16.4k| return IGRAPH_SUCCESS;
367| 16.4k|}
igraph_add_vertices:
391| 32.8k|) {
392| 32.8k| igraph_int_t ec = igraph_ecount(graph);
393| 32.8k| igraph_int_t vc = igraph_vcount(graph);
394| 32.8k| igraph_int_t new_vc;
395| 32.8k| igraph_int_t i;
396| |
397| 32.8k| if (nv < 0) {
------------------
| Branch (397:9): [True: 0, False: 32.8k]
------------------
398| 0| IGRAPH_ERROR("Cannot add negative number of vertices.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
399| 0| }
400| |
401| 32.8k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc);
------------------
| | 47| 32.8k| do { \
| | 48| 32.8k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 32.8k| igraph_int_t _safe_sum; \
| | 50| 32.8k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 32.8k]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 32.8k| *(res) = _safe_sum; \
| | 54| 32.8k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 32.8k]
| | ------------------
------------------
402| 32.8k| if (new_vc > IGRAPH_VCOUNT_MAX) {
------------------
| | 100| 32.8k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1)
| | ------------------
| | | | 72| 32.8k|# define IGRAPH_INTEGER_MAX INT64_MAX
| | ------------------
------------------
| Branch (402:9): [True: 0, False: 32.8k]
------------------
403| 0| IGRAPH_ERRORF("Maximum vertex count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
404| 0| IGRAPH_VCOUNT_MAX);
405| 0| }
406| 32.8k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1));
------------------
| | 656| 32.8k| do { \
| | 657| 32.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 32.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.8k]
| | ------------------
------------------
407| 32.8k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1));
------------------
| | 656| 32.8k| do { \
| | 657| 32.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 32.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.8k]
| | ------------------
------------------
408| |
409| 32.8k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */
410| 32.8k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */
411| 184k| for (i = graph->n + 1; i < new_vc + 1; i++) {
------------------
| Branch (411:28): [True: 151k, False: 32.8k]
------------------
412| 151k| VECTOR(graph->os)[i] = ec;
------------------
| | 60| 151k|#define VECTOR(v) ((v).stor_begin)
------------------
413| 151k| VECTOR(graph->is)[i] = ec;
------------------
| | 60| 151k|#define VECTOR(v) ((v).stor_begin)
------------------
414| 151k| }
415| |
416| 32.8k| graph->n += nv;
417| |
418| | /* Add attributes if necessary. This section is protected with
419| | * FINALLY_ENTER/EXIT so that the graph would not be accidentally
420| | * free upon error until it could be restored to a consistent state. */
421| |
422| 32.8k| if (graph->attr) {
------------------
| Branch (422:9): [True: 32.8k, False: 0]
------------------
423| 32.8k| igraph_error_t err;
424| 32.8k| IGRAPH_FINALLY_ENTER();
425| 32.8k| err = igraph_i_attribute_add_vertices(graph, nv, attr);
426| 32.8k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (426:13): [True: 0, False: 32.8k]
------------------
427| | /* Restore original vertex count on failure */
428| 0| graph->n = vc;
429| 0| igraph_vector_int_resize(&graph->os, vc + 1); /* shrinks */
430| 0| igraph_vector_int_resize(&graph->is, vc + 1); /* shrinks */
431| 0| }
432| 32.8k| IGRAPH_FINALLY_EXIT();
433| 32.8k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (433:13): [True: 0, False: 32.8k]
------------------
434| 0| IGRAPH_ERROR("Cannot add vertices.", err);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
435| 0| }
436| 32.8k| }
437| |
438| | /* modification successful, clear the cached properties of the graph.
439| | *
440| | * Adding one or more nodes does not change the following cached properties:
441| | *
442| | * - IGRAPH_PROP_HAS_LOOP
443| | * - IGRAPH_PROP_HAS_MULTI
444| | * - IGRAPH_PROP_HAS_MUTUAL
445| | * - IGRAPH_PROP_IS_DAG (adding a node does not create/destroy cycles)
446| | * - IGRAPH_PROP_IS_FOREST (same)
447| | *
448| | * Adding one or more nodes without any edges incident on them is sure to
449| | * make the graph disconnected (weakly or strongly), so we can keep the
450| | * connectivity-related properties if they are currently cached as false.
451| | * (Actually, even if they weren't cached as false, we could still set them
452| | * to false, but we don't have that functionality yet). The only exception
453| | * is when the graph had zero vertices and gained only one vertex, because
454| | * it then becomes connected. That's why we have the condition below in the
455| | * keep_when_false section.
456| | */
457| 32.8k| igraph_i_property_cache_invalidate_conditionally(
458| 32.8k| graph,
459| | /* keep_always = */
460| 32.8k| (1 << IGRAPH_PROP_HAS_LOOP) |
461| 32.8k| (1 << IGRAPH_PROP_HAS_MULTI) |
462| 32.8k| (1 << IGRAPH_PROP_HAS_MUTUAL) |
463| 32.8k| (1 << IGRAPH_PROP_IS_DAG) |
464| 32.8k| (1 << IGRAPH_PROP_IS_FOREST),
465| | /* keep_when_false = */
466| 32.8k| igraph_vcount(graph) >= 2 ? (
------------------
| Branch (466:9): [True: 11.1k, False: 21.6k]
------------------
467| 11.1k| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) |
468| 11.1k| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED)
469| 21.6k| ) : 0,
470| | /* keep_when_true = */
471| 32.8k| 0
472| 32.8k| );
473| |
474| 32.8k| return IGRAPH_SUCCESS;
475| 32.8k|}
igraph_vcount:
829| 679k|igraph_int_t igraph_vcount(const igraph_t *graph) {
830| 679k| return graph->n;
831| 679k|}
igraph_ecount:
843| 3.27M|igraph_int_t igraph_ecount(const igraph_t *graph) {
844| 3.27M| return igraph_vector_int_size(&graph->from);
845| 3.27M|}
igraph_is_directed:
1133| 2.17M|igraph_bool_t igraph_is_directed(const igraph_t *graph) {
1134| 2.17M| return graph->directed;
1135| 2.17M|}
igraph_get_eid:
1524| 344k| igraph_bool_t directed, igraph_bool_t error) {
1525| |
1526| 344k| igraph_int_t no_of_nodes = igraph_vcount(graph);
1527| |
1528| 344k| if (from < 0 || to < 0 || from >= no_of_nodes || to >= no_of_nodes) {
------------------
| Branch (1528:9): [True: 0, False: 344k]
| Branch (1528:21): [True: 0, False: 344k]
| Branch (1528:31): [True: 0, False: 344k]
| Branch (1528:54): [True: 0, False: 344k]
------------------
1529| 0| IGRAPH_ERROR("Cannot get edge ID.", IGRAPH_EINVVID);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1530| 0| }
1531| |
1532| 344k| *eid = -1;
1533| 344k| if (igraph_is_directed(graph)) {
------------------
| Branch (1533:9): [True: 119k, False: 224k]
------------------
1534| |
1535| | /* Directed graph */
1536| 119k| FIND_DIRECTED_EDGE(graph, from, to, eid);
------------------
| | 1469| 119k| do { \
| | 1470| 119k| igraph_int_t start = VECTOR(graph->os)[xfrom]; \
| | ------------------
| | | | 60| 119k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1471| 119k| igraph_int_t end = VECTOR(graph->os)[xfrom+1]; \
| | ------------------
| | | | 60| 119k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1472| 119k| igraph_int_t N = end; \
| | 1473| 119k| igraph_int_t start2 = VECTOR(graph->is)[xto]; \
| | ------------------
| | | | 60| 119k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1474| 119k| igraph_int_t end2 = VECTOR(graph->is)[xto+1]; \
| | ------------------
| | | | 60| 119k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1475| 119k| igraph_int_t N2 = end2; \
| | 1476| 119k| igraph_int_t *nullpointer = NULL; \
| | 1477| 119k| if (end-start < end2-start2) { \
| | ------------------
| | | Branch (1477:13): [True: 47.6k, False: 71.8k]
| | ------------------
| | 1478| 47.6k| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \
| | ------------------
| | | | 1449| 47.6k| do { \
| | | | 1450| 259k| while ((start) < (end)) { \
| | | | ------------------
| | | | | Branch (1450:16): [True: 212k, False: 47.6k]
| | | | ------------------
| | | | 1451| 212k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | 1452| 212k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | ------------------
| | | | | | 60| 212k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1453| 212k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | ------------------
| | | | | | 60| 212k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1453:17): [True: 58.0k, False: 154k]
| | | | ------------------
| | | | 1454| 58.0k| (start) = mid+1; \
| | | | 1455| 154k| } else { \
| | | | 1456| 154k| (end) = mid; \
| | | | 1457| 154k| } \
| | | | 1458| 212k| } \
| | | | 1459| 47.6k| if ((start) < (N)) { \
| | | | ------------------
| | | | | Branch (1459:13): [True: 24.7k, False: 22.8k]
| | | | ------------------
| | | | 1460| 24.7k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | ------------------
| | | | | | 60| 24.7k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1461| 24.7k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | ------------------
| | | | | | 60| 24.7k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1461:17): [True: 12.5k, False: 12.1k]
| | | | ------------------
| | | | 1462| 12.5k| *(result) = e; \
| | | | 1463| 12.5k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | ------------------
| | | | | Branch (1463:21): [True: 0, False: 12.5k]
| | | | ------------------
| | | | 1464| 12.5k| } \
| | | | 1465| 24.7k| } \
| | | | 1466| 47.6k| } while (0)
| | | | ------------------
| | | | | Branch (1466:14): [Folded, False: 47.6k]
| | | | ------------------
| | ------------------
| | 1479| 71.8k| } else { \
| | 1480| 71.8k| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \
| | ------------------
| | | | 1449| 71.8k| do { \
| | | | 1450| 675k| while ((start) < (end)) { \
| | | | ------------------
| | | | | Branch (1450:16): [True: 603k, False: 71.8k]
| | | | ------------------
| | | | 1451| 603k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | 1452| 603k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | ------------------
| | | | | | 60| 603k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1453| 603k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | ------------------
| | | | | | 60| 603k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1453:17): [True: 31.4k, False: 571k]
| | | | ------------------
| | | | 1454| 31.4k| (start) = mid+1; \
| | | | 1455| 571k| } else { \
| | | | 1456| 571k| (end) = mid; \
| | | | 1457| 571k| } \
| | | | 1458| 603k| } \
| | | | 1459| 71.8k| if ((start) < (N)) { \
| | | | ------------------
| | | | | Branch (1459:13): [True: 68.1k, False: 3.68k]
| | | | ------------------
| | | | 1460| 68.1k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | ------------------
| | | | | | 60| 68.1k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1461| 68.1k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | ------------------
| | | | | | 60| 68.1k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1461:17): [True: 26.1k, False: 41.9k]
| | | | ------------------
| | | | 1462| 26.1k| *(result) = e; \
| | | | 1463| 26.1k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | ------------------
| | | | | Branch (1463:21): [True: 0, False: 26.1k]
| | | | ------------------
| | | | 1464| 26.1k| } \
| | | | 1465| 68.1k| } \
| | | | 1466| 71.8k| } while (0)
| | | | ------------------
| | | | | Branch (1466:14): [Folded, False: 71.8k]
| | | | ------------------
| | ------------------
| | 1481| 71.8k| } \
| | 1482| 119k| } while (0)
| | ------------------
| | | Branch (1482:14): [Folded, False: 119k]
| | ------------------
------------------
1537| 119k| if (!directed && *eid < 0) {
------------------
| Branch (1537:13): [True: 0, False: 119k]
| Branch (1537:26): [True: 0, False: 0]
------------------
1538| 0| FIND_DIRECTED_EDGE(graph, to, from, eid);
------------------
| | 1469| 0| do { \
| | 1470| 0| igraph_int_t start = VECTOR(graph->os)[xfrom]; \
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1471| 0| igraph_int_t end = VECTOR(graph->os)[xfrom+1]; \
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1472| 0| igraph_int_t N = end; \
| | 1473| 0| igraph_int_t start2 = VECTOR(graph->is)[xto]; \
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1474| 0| igraph_int_t end2 = VECTOR(graph->is)[xto+1]; \
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1475| 0| igraph_int_t N2 = end2; \
| | 1476| 0| igraph_int_t *nullpointer = NULL; \
| | 1477| 0| if (end-start < end2-start2) { \
| | ------------------
| | | Branch (1477:13): [True: 0, False: 0]
| | ------------------
| | 1478| 0| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \
| | ------------------
| | | | 1449| 0| do { \
| | | | 1450| 0| while ((start) < (end)) { \
| | | | ------------------
| | | | | Branch (1450:16): [True: 0, False: 0]
| | | | ------------------
| | | | 1451| 0| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | 1452| 0| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | ------------------
| | | | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1453| 0| if (VECTOR((edgelist))[e] < (value)) { \
| | | | ------------------
| | | | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1453:17): [True: 0, False: 0]
| | | | ------------------
| | | | 1454| 0| (start) = mid+1; \
| | | | 1455| 0| } else { \
| | | | 1456| 0| (end) = mid; \
| | | | 1457| 0| } \
| | | | 1458| 0| } \
| | | | 1459| 0| if ((start) < (N)) { \
| | | | ------------------
| | | | | Branch (1459:13): [True: 0, False: 0]
| | | | ------------------
| | | | 1460| 0| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | ------------------
| | | | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1461| 0| if (VECTOR((edgelist))[e] == (value)) { \
| | | | ------------------
| | | | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1461:17): [True: 0, False: 0]
| | | | ------------------
| | | | 1462| 0| *(result) = e; \
| | | | 1463| 0| if (result_pos != 0) { *(result_pos) = start; } \
| | | | ------------------
| | | | | Branch (1463:21): [True: 0, False: 0]
| | | | ------------------
| | | | 1464| 0| } \
| | | | 1465| 0| } \
| | | | 1466| 0| } while (0)
| | | | ------------------
| | | | | Branch (1466:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 1479| 0| } else { \
| | 1480| 0| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \
| | ------------------
| | | | 1449| 0| do { \
| | | | 1450| 0| while ((start) < (end)) { \
| | | | ------------------
| | | | | Branch (1450:16): [True: 0, False: 0]
| | | | ------------------
| | | | 1451| 0| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | 1452| 0| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | ------------------
| | | | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1453| 0| if (VECTOR((edgelist))[e] < (value)) { \
| | | | ------------------
| | | | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1453:17): [True: 0, False: 0]
| | | | ------------------
| | | | 1454| 0| (start) = mid+1; \
| | | | 1455| 0| } else { \
| | | | 1456| 0| (end) = mid; \
| | | | 1457| 0| } \
| | | | 1458| 0| } \
| | | | 1459| 0| if ((start) < (N)) { \
| | | | ------------------
| | | | | Branch (1459:13): [True: 0, False: 0]
| | | | ------------------
| | | | 1460| 0| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | ------------------
| | | | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1461| 0| if (VECTOR((edgelist))[e] == (value)) { \
| | | | ------------------
| | | | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1461:17): [True: 0, False: 0]
| | | | ------------------
| | | | 1462| 0| *(result) = e; \
| | | | 1463| 0| if (result_pos != 0) { *(result_pos) = start; } \
| | | | ------------------
| | | | | Branch (1463:21): [True: 0, False: 0]
| | | | ------------------
| | | | 1464| 0| } \
| | | | 1465| 0| } \
| | | | 1466| 0| } while (0)
| | | | ------------------
| | | | | Branch (1466:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 1481| 0| } \
| | 1482| 0| } while (0)
| | ------------------
| | | Branch (1482:14): [Folded, False: 0]
| | ------------------
------------------
1539| 0| }
1540| |
1541| 224k| } else {
1542| |
1543| | /* Undirected graph, they only have one mode */
1544| 224k| FIND_UNDIRECTED_EDGE(graph, from, to, eid);
------------------
| | 1485| 224k| do { \
| | 1486| 224k| igraph_int_t xfrom1 = from > to ? from : to; \
| | ------------------
| | | Branch (1486:31): [True: 218k, False: 5.73k]
| | ------------------
| | 1487| 224k| igraph_int_t xto1 = from > to ? to : from; \
| | ------------------
| | | Branch (1487:29): [True: 218k, False: 5.73k]
| | ------------------
| | 1488| 224k| FIND_DIRECTED_EDGE(graph, xfrom1, xto1, eid); \
| | ------------------
| | | | 1469| 224k| do { \
| | | | 1470| 224k| igraph_int_t start = VECTOR(graph->os)[xfrom]; \
| | | | ------------------
| | | | | | 60| 224k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1471| 224k| igraph_int_t end = VECTOR(graph->os)[xfrom+1]; \
| | | | ------------------
| | | | | | 60| 224k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1472| 224k| igraph_int_t N = end; \
| | | | 1473| 224k| igraph_int_t start2 = VECTOR(graph->is)[xto]; \
| | | | ------------------
| | | | | | 60| 224k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1474| 224k| igraph_int_t end2 = VECTOR(graph->is)[xto+1]; \
| | | | ------------------
| | | | | | 60| 224k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1475| 224k| igraph_int_t N2 = end2; \
| | | | 1476| 224k| igraph_int_t *nullpointer = NULL; \
| | | | 1477| 224k| if (end-start < end2-start2) { \
| | | | ------------------
| | | | | Branch (1477:13): [True: 199k, False: 25.6k]
| | | | ------------------
| | | | 1478| 199k| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \
| | | | ------------------
| | | | | | 1449| 199k| do { \
| | | | | | 1450| 2.19M| while ((start) < (end)) { \
| | | | | | ------------------
| | | | | | | Branch (1450:16): [True: 1.99M, False: 199k]
| | | | | | ------------------
| | | | | | 1451| 1.99M| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | | | 1452| 1.99M| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | | | ------------------
| | | | | | | | 60| 1.99M|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1453| 1.99M| if (VECTOR((edgelist))[e] < (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 1.99M|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1453:17): [True: 34.5k, False: 1.96M]
| | | | | | ------------------
| | | | | | 1454| 34.5k| (start) = mid+1; \
| | | | | | 1455| 1.96M| } else { \
| | | | | | 1456| 1.96M| (end) = mid; \
| | | | | | 1457| 1.96M| } \
| | | | | | 1458| 1.99M| } \
| | | | | | 1459| 199k| if ((start) < (N)) { \
| | | | | | ------------------
| | | | | | | Branch (1459:13): [True: 199k, False: 0]
| | | | | | ------------------
| | | | | | 1460| 199k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | | | ------------------
| | | | | | | | 60| 199k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1461| 199k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 199k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1461:17): [True: 199k, False: 0]
| | | | | | ------------------
| | | | | | 1462| 199k| *(result) = e; \
| | | | | | 1463| 199k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | | | ------------------
| | | | | | | Branch (1463:21): [True: 0, False: 199k]
| | | | | | ------------------
| | | | | | 1464| 199k| } \
| | | | | | 1465| 199k| } \
| | | | | | 1466| 199k| } while (0)
| | | | | | ------------------
| | | | | | | Branch (1466:14): [Folded, False: 199k]
| | | | | | ------------------
| | | | ------------------
| | | | 1479| 199k| } else { \
| | | | 1480| 25.6k| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \
| | | | ------------------
| | | | | | 1449| 25.6k| do { \
| | | | | | 1450| 152k| while ((start) < (end)) { \
| | | | | | ------------------
| | | | | | | Branch (1450:16): [True: 127k, False: 25.6k]
| | | | | | ------------------
| | | | | | 1451| 127k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | | | 1452| 127k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | | | ------------------
| | | | | | | | 60| 127k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1453| 127k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 127k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1453:17): [True: 8.45k, False: 118k]
| | | | | | ------------------
| | | | | | 1454| 8.45k| (start) = mid+1; \
| | | | | | 1455| 118k| } else { \
| | | | | | 1456| 118k| (end) = mid; \
| | | | | | 1457| 118k| } \
| | | | | | 1458| 127k| } \
| | | | | | 1459| 25.6k| if ((start) < (N)) { \
| | | | | | ------------------
| | | | | | | Branch (1459:13): [True: 25.6k, False: 0]
| | | | | | ------------------
| | | | | | 1460| 25.6k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | | | ------------------
| | | | | | | | 60| 25.6k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1461| 25.6k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 25.6k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1461:17): [True: 25.6k, False: 0]
| | | | | | ------------------
| | | | | | 1462| 25.6k| *(result) = e; \
| | | | | | 1463| 25.6k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | | | ------------------
| | | | | | | Branch (1463:21): [True: 0, False: 25.6k]
| | | | | | ------------------
| | | | | | 1464| 25.6k| } \
| | | | | | 1465| 25.6k| } \
| | | | | | 1466| 25.6k| } while (0)
| | | | | | ------------------
| | | | | | | Branch (1466:14): [Folded, False: 25.6k]
| | | | | | ------------------
| | | | ------------------
| | | | 1481| 25.6k| } \
| | | | 1482| 224k| } while (0)
| | | | ------------------
| | | | | Branch (1482:14): [Folded, False: 224k]
| | | | ------------------
| | ------------------
| | 1489| 224k| } while (0)
| | ------------------
| | | Branch (1489:14): [Folded, False: 224k]
| | ------------------
------------------
1545| |
1546| 224k| }
1547| |
1548| 344k| if (*eid < 0) {
------------------
| Branch (1548:9): [True: 80.6k, False: 263k]
------------------
1549| 80.6k| if (error) {
------------------
| Branch (1549:13): [True: 0, False: 80.6k]
------------------
1550| 0| IGRAPH_ERROR("Cannot get edge ID, no such edge.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1551| 0| }
1552| 80.6k| }
1553| |
1554| 344k| return IGRAPH_SUCCESS;
1555| 344k|}
igraph_incident:
1778| 66.9k|) {
1779| 66.9k| igraph_int_t length = 0, idx = 0;
1780| 66.9k| igraph_int_t i, j;
1781| 66.9k| igraph_int_t node = pnode;
1782| 66.9k| igraph_bool_t directed = igraph_is_directed(graph);
1783| |
1784| 66.9k| if (node < 0 || node > igraph_vcount(graph) - 1) {
------------------
| Branch (1784:9): [True: 0, False: 66.9k]
| Branch (1784:21): [True: 0, False: 66.9k]
------------------
1785| 0| IGRAPH_ERRORF("Vertex %" IGRAPH_PRId " is not in the graph.", IGRAPH_EINVVID, node);
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
1786| 0| }
1787| 66.9k| if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
------------------
| Branch (1787:9): [True: 64.5k, False: 2.40k]
| Branch (1787:31): [True: 64.5k, False: 0]
------------------
1788| 64.5k| mode != IGRAPH_ALL) {
------------------
| Branch (1788:9): [True: 0, False: 64.5k]
------------------
1789| 0| IGRAPH_ERROR("Mode should be either IGRAPH_OUT, IGRAPH_IN or IGRAPH_ALL.", IGRAPH_EINVMODE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1790| 0| }
1791| |
1792| 66.9k| if (!directed) {
------------------
| Branch (1792:9): [True: 64.5k, False: 2.40k]
------------------
1793| 64.5k| mode = IGRAPH_ALL;
1794| 64.5k| }
1795| |
1796| 66.9k| if (mode != IGRAPH_ALL && loops == IGRAPH_LOOPS_TWICE) {
------------------
| Branch (1796:9): [True: 2.40k, False: 64.5k]
| Branch (1796:31): [True: 2.40k, False: 0]
------------------
1797| | /*
1798| | IGRAPH_ERROR("For a directed graph (with directions not ignored), "
1799| | "IGRAPH_LOOPS_TWICE does not make sense.", IGRAPH_EINVAL);
1800| | */
1801| 2.40k| loops = IGRAPH_LOOPS_ONCE;
1802| 2.40k| }
1803| |
1804| | /* Calculate needed space first & allocate it */
1805| | /* Note that 'mode' is treated as a bit field here; it's okay because
1806| | * IGRAPH_ALL = IGRAPH_IN | IGRAPH_OUT, bit-wise */
1807| 66.9k| if (mode & IGRAPH_OUT) {
------------------
| Branch (1807:9): [True: 66.9k, False: 0]
------------------
1808| 66.9k| length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]);
------------------
| | 60| 66.9k|#define VECTOR(v) ((v).stor_begin)
------------------
length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]);
------------------
| | 60| 66.9k|#define VECTOR(v) ((v).stor_begin)
------------------
1809| 66.9k| }
1810| 66.9k| if (mode & IGRAPH_IN) {
------------------
| Branch (1810:9): [True: 64.5k, False: 2.40k]
------------------
1811| 64.5k| length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]);
------------------
| | 60| 64.5k|#define VECTOR(v) ((v).stor_begin)
------------------
length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]);
------------------
| | 60| 64.5k|#define VECTOR(v) ((v).stor_begin)
------------------
1812| 64.5k| }
1813| |
1814| 66.9k| IGRAPH_CHECK(igraph_vector_int_resize(eids, length));
------------------
| | 656| 66.9k| do { \
| | 657| 66.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 66.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 66.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 66.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 66.9k]
| | ------------------
------------------
1815| |
1816| | /* The loops below produce an ordering what is consistent with the
1817| | * ordering returned by igraph_neighbors(), and this should be preserved.
1818| | * We are dealing with two sorted lists; one for the successors and one
1819| | * for the predecessors. If we have requested only one of them, we have
1820| | * an easy job. If we have requested both, we need to merge the two lists
1821| | * to ensure that the output is sorted by the vertex IDs of the "other"
1822| | * endpoint of the affected edges */
1823| 66.9k| if (!directed || mode != IGRAPH_ALL) {
------------------
| Branch (1823:9): [True: 64.5k, False: 2.40k]
| Branch (1823:22): [True: 2.40k, False: 0]
------------------
1824| | /* We did not ask for both directions; this is the easy case */
1825| |
1826| 66.9k| if (mode & IGRAPH_OUT) {
------------------
| Branch (1826:13): [True: 66.9k, False: 0]
------------------
1827| 66.9k| j = VECTOR(graph->os)[node + 1];
------------------
| | 60| 66.9k|#define VECTOR(v) ((v).stor_begin)
------------------
1828| 756k| for (i = VECTOR(graph->os)[node]; i < j; i++) {
------------------
| | 60| 66.9k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1828:47): [True: 689k, False: 66.9k]
------------------
1829| 689k| igraph_int_t edge = VECTOR(graph->oi)[i];
------------------
| | 60| 689k|#define VECTOR(v) ((v).stor_begin)
------------------
1830| 689k| igraph_int_t other = VECTOR(graph->to)[edge];
------------------
| | 60| 689k|#define VECTOR(v) ((v).stor_begin)
------------------
1831| 689k| if (loops == IGRAPH_NO_LOOPS && other == pnode) {
------------------
| Branch (1831:21): [True: 0, False: 689k]
| Branch (1831:49): [True: 0, False: 0]
------------------
1832| 0| length--;
1833| 689k| } else {
1834| 689k| VECTOR(*eids)[idx++] = edge;
------------------
| | 60| 689k|#define VECTOR(v) ((v).stor_begin)
------------------
1835| 689k| }
1836| 689k| }
1837| 66.9k| }
1838| |
1839| 66.9k| if (mode & IGRAPH_IN) {
------------------
| Branch (1839:13): [True: 64.5k, False: 2.40k]
------------------
1840| 64.5k| j = VECTOR(graph->is)[node + 1];
------------------
| | 60| 64.5k|#define VECTOR(v) ((v).stor_begin)
------------------
1841| 515k| for (i = VECTOR(graph->is)[node]; i < j; i++) {
------------------
| | 60| 64.5k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1841:47): [True: 451k, False: 64.5k]
------------------
1842| 451k| igraph_int_t edge = VECTOR(graph->ii)[i];
------------------
| | 60| 451k|#define VECTOR(v) ((v).stor_begin)
------------------
1843| 451k| igraph_int_t other = VECTOR(graph->from)[edge];
------------------
| | 60| 451k|#define VECTOR(v) ((v).stor_begin)
------------------
1844| 451k| if ((loops == IGRAPH_NO_LOOPS || (loops == IGRAPH_LOOPS_ONCE && !directed)) && other == pnode) {
------------------
| Branch (1844:22): [True: 0, False: 451k]
| Branch (1844:51): [True: 0, False: 451k]
| Branch (1844:81): [True: 0, False: 0]
| Branch (1844:96): [True: 0, False: 0]
------------------
1845| 0| length--;
1846| 451k| } else {
1847| 451k| VECTOR(*eids)[idx++] = edge;
------------------
| | 60| 451k|#define VECTOR(v) ((v).stor_begin)
------------------
1848| 451k| }
1849| 451k| }
1850| 64.5k| }
1851| 66.9k| } else {
1852| | /* both in- and out- neighbors in a directed graph,
1853| | we need to merge the two 'vectors' */
1854| 0| igraph_int_t j1 = VECTOR(graph->os)[node + 1];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1855| 0| igraph_int_t j2 = VECTOR(graph->is)[node + 1];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1856| 0| igraph_int_t i1 = VECTOR(graph->os)[node];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1857| 0| igraph_int_t i2 = VECTOR(graph->is)[node];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1858| 0| igraph_int_t eid1, eid2;
1859| 0| igraph_int_t n1, n2;
1860| 0| igraph_bool_t seen_loop_edge = false;
1861| |
1862| 0| while (i1 < j1 && i2 < j2) {
------------------
| Branch (1862:16): [True: 0, False: 0]
| Branch (1862:27): [True: 0, False: 0]
------------------
1863| 0| eid1 = VECTOR(graph->oi)[i1];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1864| 0| eid2 = VECTOR(graph->ii)[i2];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1865| 0| n1 = VECTOR(graph->to)[eid1];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1866| 0| n2 = VECTOR(graph->from)[eid2];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1867| 0| if (n1 < n2) {
------------------
| Branch (1867:17): [True: 0, False: 0]
------------------
1868| 0| i1++;
1869| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1870| 0| } else if (n1 > n2) {
------------------
| Branch (1870:24): [True: 0, False: 0]
------------------
1871| 0| i2++;
1872| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1873| 0| } else if (n1 != pnode) {
------------------
| Branch (1873:24): [True: 0, False: 0]
------------------
1874| | /* multiple edge */
1875| 0| i1++;
1876| 0| i2++;
1877| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1878| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1879| 0| } else {
1880| | /* loop edge */
1881| 0| i1++;
1882| 0| i2++;
1883| 0| if (loops == IGRAPH_NO_LOOPS) {
------------------
| Branch (1883:21): [True: 0, False: 0]
------------------
1884| 0| length -= 2;
1885| 0| } else if (loops == IGRAPH_LOOPS_ONCE) {
------------------
| Branch (1885:28): [True: 0, False: 0]
------------------
1886| 0| length--;
1887| 0| if (!seen_loop_edge) {
------------------
| Branch (1887:25): [True: 0, False: 0]
------------------
1888| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1889| 0| } else {
1890| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1891| 0| }
1892| 0| seen_loop_edge = !seen_loop_edge;
1893| 0| } else {
1894| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1895| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1896| 0| }
1897| 0| }
1898| 0| }
1899| |
1900| 0| while (i1 < j1) {
------------------
| Branch (1900:16): [True: 0, False: 0]
------------------
1901| 0| eid1 = VECTOR(graph->oi)[i1++];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1902| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1903| 0| }
1904| |
1905| 0| while (i2 < j2) {
------------------
| Branch (1905:16): [True: 0, False: 0]
------------------
1906| 0| eid2 = VECTOR(graph->ii)[i2++];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1907| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1908| 0| }
1909| 0| }
1910| 66.9k| IGRAPH_CHECK(igraph_vector_int_resize(eids, length));
------------------
| | 656| 66.9k| do { \
| | 657| 66.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 66.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 66.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 66.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 66.9k]
| | ------------------
------------------
1911| 66.9k| return IGRAPH_SUCCESS;
1912| 66.9k|}
type_indexededgelist.c:igraph_i_create_start_vectors:
1076| 32.8k| igraph_vector_int_t *iindex, igraph_int_t nodes) {
1077| |
1078| 32.8k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
1079| |
1080| 32.8k| igraph_int_t no_of_nodes;
1081| 32.8k| igraph_int_t no_of_edges;
1082| 32.8k| igraph_int_t i, j, idx;
1083| |
1084| 32.8k| no_of_nodes = nodes;
1085| 32.8k| no_of_edges = igraph_vector_int_size(el);
1086| |
1087| | /* result */
1088| |
1089| 32.8k| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1));
------------------
| | 656| 32.8k| do { \
| | 657| 32.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 32.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.8k]
| | ------------------
------------------
1090| |
1091| | /* create the index */
1092| |
1093| 32.8k| if (no_of_edges == 0) {
------------------
| Branch (1093:9): [True: 8.86k, False: 23.9k]
------------------
1094| | /* empty graph */
1095| 8.86k| igraph_vector_int_null(res);
1096| 23.9k| } else {
1097| 23.9k| idx = -1;
1098| 58.9k| for (i = 0; i <= EDGE(0); i++) {
------------------
| | 1078| 58.9k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 58.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 58.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (1098:21): [True: 34.9k, False: 23.9k]
------------------
1099| 34.9k| idx++; VECTOR(*res)[idx] = 0;
------------------
| | 60| 34.9k|#define VECTOR(v) ((v).stor_begin)
------------------
1100| 34.9k| }
1101| 3.44M| for (i = 1; i < no_of_edges; i++) {
------------------
| Branch (1101:21): [True: 3.41M, False: 23.9k]
------------------
1102| 3.41M| igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 3.41M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 3.41M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 3.41M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 3.41M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 3.41M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 3.41M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1103| 3.66M| for (j = 0; j < n; j++) {
------------------
| Branch (1103:25): [True: 248k, False: 3.41M]
------------------
1104| 248k| idx++; VECTOR(*res)[idx] = i;
------------------
| | 60| 248k|#define VECTOR(v) ((v).stor_begin)
------------------
1105| 248k| }
1106| 3.41M| }
1107| 23.9k| j = EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 23.9k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 23.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 23.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1108| 66.5k| for (i = 0; i < no_of_nodes - j; i++) {
------------------
| Branch (1108:21): [True: 42.5k, False: 23.9k]
------------------
1109| 42.5k| idx++; VECTOR(*res)[idx] = no_of_edges;
------------------
| | 60| 42.5k|#define VECTOR(v) ((v).stor_begin)
------------------
1110| 42.5k| }
1111| 23.9k| }
1112| |
1113| | /* clean */
1114| |
1115| 32.8k|# undef EDGE
1116| 32.8k| return IGRAPH_SUCCESS;
1117| 32.8k|}
igraph_qsort:
264| 37|{
265| | local_qsort(a, n, es, cmp, NULL);
266| 37|}
qsort.c:local_qsort:
121| 37|{
122| 37| char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
123| 37| size_t d1, d2;
124| 37| int cmp_result;
125| 37| int swap_cnt;
126| |
127| | /* if there are less than 2 elements, then sorting is not needed */
128| 37| if (IGRAPH_UNLIKELY(n < 2))
------------------
| | 612| 37| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | ------------------
| | | Branch (612:32): [True: 0, False: 37]
| | ------------------
------------------
129| 0| return;
130| 37|loop:
131| 37| swap_cnt = 0;
132| 37| if (n < 7) {
------------------
| Branch (132:6): [True: 5, False: 32]
------------------
133| 20| for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
------------------
| Branch (133:29): [True: 15, False: 5]
------------------
134| 15| for (pl = pm;
135| 15| pl > (char *)a && CMP(thunk, pl - es, pl) > 0;
------------------
| | 95| 15|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (135:9): [True: 15, False: 0]
| Branch (135:27): [True: 0, False: 15]
------------------
136| 15| pl -= es)
137| 0| swapfunc(pl, pl - es, es);
138| 5| return;
139| 5| }
140| 32| pm = (char *)a + (n / 2) * es;
141| 32| if (n > 7) {
------------------
| Branch (141:6): [True: 31, False: 1]
------------------
142| 31| pl = a;
143| 31| pn = (char *)a + (n - 1) * es;
144| 31| if (n > 40) {
------------------
| Branch (144:7): [True: 15, False: 16]
------------------
145| 15| size_t d = (n / 8) * es;
146| |
147| 15| pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk);
148| 15| pm = med3(pm - d, pm, pm + d, cmp, thunk);
149| 15| pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk);
150| 15| }
151| 31| pm = med3(pl, pm, pn, cmp, thunk);
152| 31| }
153| 32| swapfunc(a, pm, es);
154| 32| pa = pb = (char *)a + es;
155| |
156| 32| pc = pd = (char *)a + (n - 1) * es;
157| 32| for (;;) {
158| 1.94k| while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) {
------------------
| | 95| 1.91k|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (158:10): [True: 1.91k, False: 32]
| Branch (158:22): [True: 1.91k, False: 0]
------------------
159| 1.91k| if (cmp_result == 0) {
------------------
| Branch (159:8): [True: 1.91k, False: 0]
------------------
160| 1.91k| swap_cnt = 1;
161| 1.91k| swapfunc(pa, pb, es);
162| 1.91k| pa += es;
163| 1.91k| }
164| 1.91k| pb += es;
165| 1.91k| }
166| 32| while (pb <= pc && (cmp_result = CMP(thunk, pc, a)) >= 0) {
------------------
| | 95| 0|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (166:10): [True: 0, False: 32]
| Branch (166:22): [True: 0, False: 0]
------------------
167| 0| if (cmp_result == 0) {
------------------
| Branch (167:8): [True: 0, False: 0]
------------------
168| 0| swap_cnt = 1;
169| 0| swapfunc(pc, pd, es);
170| 0| pd -= es;
171| 0| }
172| 0| pc -= es;
173| 0| }
174| 32| if (pb > pc)
------------------
| Branch (174:7): [True: 32, False: 0]
------------------
175| 32| break;
176| 0| swapfunc(pb, pc, es);
177| 0| swap_cnt = 1;
178| 0| pb += es;
179| 0| pc -= es;
180| 0| }
181| 32| if (swap_cnt == 0) { /* Switch to insertion sort */
------------------
| Branch (181:6): [True: 0, False: 32]
------------------
182| 0| for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
------------------
| Branch (182:29): [True: 0, False: 0]
------------------
183| 0| for (pl = pm;
184| 0| pl > (char *)a && CMP(thunk, pl - es, pl) > 0;
------------------
| | 95| 0|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (184:9): [True: 0, False: 0]
| Branch (184:27): [True: 0, False: 0]
------------------
185| 0| pl -= es)
186| 0| swapfunc(pl, pl - es, es);
187| 0| return;
188| 0| }
189| |
190| 32| pn = (char *)a + n * es;
191| 32| d1 = MIN(pa - (char *)a, pb - pa);
------------------
| | 69| 32|#define MIN(a, b) ((a) < (b) ? a : b)
| | ------------------
| | | Branch (69:20): [True: 0, False: 32]
| | ------------------
------------------
192| 32| vecswap(a, pb - d1, d1);
------------------
| | 88| 32| if ((n) > 0) swapfunc(a, b, n)
| | ------------------
| | | Branch (88:6): [True: 0, False: 32]
| | ------------------
------------------
193| | /*
194| | * Cast es to preserve signedness of right-hand side of MIN()
195| | * expression, to avoid sign ambiguity in the implied comparison. es
196| | * is safely within [0, SSIZE_MAX].
197| | */
198| 32| d1 = MIN(pd - pc, pn - pd - (ptrdiff_t)es);
------------------
| | 69| 32|#define MIN(a, b) ((a) < (b) ? a : b)
| | ------------------
| | | Branch (69:20): [True: 0, False: 32]
| | ------------------
------------------
199| 32| vecswap(pb, pn - d1, d1);
------------------
| | 88| 32| if ((n) > 0) swapfunc(a, b, n)
| | ------------------
| | | Branch (88:6): [True: 0, False: 32]
| | ------------------
------------------
200| |
201| 32| d1 = pb - pa;
202| 32| d2 = pd - pc;
203| 32| if (d1 <= d2) {
------------------
| Branch (203:6): [True: 32, False: 0]
------------------
204| | /* Recurse on left partition, then iterate on right partition */
205| 32| if (d1 > es) {
------------------
| Branch (205:7): [True: 0, False: 32]
------------------
206| 0| local_qsort(a, d1 / es, es, cmp, thunk);
207| 0| }
208| 32| if (d2 > es) {
------------------
| Branch (208:7): [True: 0, False: 32]
------------------
209| | /* Iterate rather than recurse to save stack space */
210| | /* qsort(pn - d2, d2 / es, es, cmp); */
211| 0| a = pn - d2;
212| 0| n = d2 / es;
213| 0| goto loop;
214| 0| }
215| 32| } else {
216| | /* Recurse on right partition, then iterate on left partition */
217| 0| if (d2 > es) {
------------------
| Branch (217:7): [True: 0, False: 0]
------------------
218| 0| local_qsort(pn - d2, d2 / es, es, cmp, thunk);
219| 0| }
220| 0| if (d1 > es) {
------------------
| Branch (220:7): [True: 0, False: 0]
------------------
221| | /* Iterate rather than recurse to save stack space */
222| | /* qsort(a, d1 / es, es, cmp); */
223| 0| n = d1 / es;
224| 0| goto loop;
225| 0| }
226| 0| }
227| 32|}
qsort.c:swapfunc:
77| 1.94k|{
78| 1.94k| char t;
79| |
80| 15.5k| do {
81| 15.5k| t = *a;
82| 15.5k| *a++ = *b;
83| 15.5k| *b++ = t;
84| 15.5k| } while (--es > 0);
------------------
| Branch (84:11): [True: 13.6k, False: 1.94k]
------------------
85| 1.94k|}
qsort.c:med3:
104| 76|{
105| 76| return CMP(thunk, a, b) < 0 ?
------------------
| | 95| 76|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (105:9): [True: 0, False: 76]
------------------
106| 0| (CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a ))
------------------
| | 95| 0|#define CMP(t, x, y) (cmp((x), (y)))
------------------
(CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a ))
------------------
| | 95| 0|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (106:10): [True: 0, False: 0]
| Branch (106:38): [True: 0, False: 0]
------------------
107| 76| :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));
------------------
| | 95| 76|#define CMP(t, x, y) (cmp((x), (y)))
------------------
:(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));
------------------
| | 95| 76|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (107:10): [True: 0, False: 76]
| Branch (107:38): [True: 0, False: 76]
------------------
108| 76|}
igraph_write_graph_dot:
160| 3.34k|igraph_error_t igraph_write_graph_dot(const igraph_t *graph, FILE* outstream) {
161| 3.34k| const igraph_int_t no_of_nodes = igraph_vcount(graph);
162| 3.34k| const igraph_int_t no_of_edges = igraph_ecount(graph);
163| 3.34k| const igraph_bool_t directed = igraph_is_directed(graph);
164| 3.34k| const char *edgeop = directed ? "->" : "--";
------------------
| Branch (164:26): [True: 137, False: 3.20k]
------------------
165| 3.34k| igraph_strvector_t gnames, vnames, enames;
166| 3.34k| igraph_vector_int_t gtypes, vtypes, etypes;
167| 3.34k| igraph_vector_t numv;
168| 3.34k| igraph_strvector_t strv;
169| 3.34k| igraph_vector_bool_t boolv;
170| 3.34k| igraph_vector_char_t buf, buf2;
171| |
172| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
173| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
174| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
175| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
176| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
177| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
178| 3.34k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
179| 3.34k| &gnames, >ypes,
180| 3.34k| &vnames, &vtypes,
181| 3.34k| &enames, &etypes));
182| |
183| 3.34k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 0);
------------------
| | 104| 3.34k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 105| 3.34k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.34k]
| | ------------------
------------------
184| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
185| 3.34k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 0);
------------------
| | 109| 3.34k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 110| 3.34k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.34k]
| | ------------------
------------------
186| |
187| 3.34k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&buf, 0);
------------------
| | 114| 3.34k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 115| 3.34k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 3.34k]
| | ------------------
------------------
188| 3.34k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&buf2, 0);
------------------
| | 114| 3.34k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 115| 3.34k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 3.34k]
| | ------------------
------------------
189| |
190| 3.34k| CHECK(fprintf(outstream, "/* Created by igraph %s */\n", IGRAPH_VERSION));
------------------
| | 37| 3.34k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 3.34k]
| | | Branch (37:116): [Folded, False: 3.34k]
| | ------------------
------------------
191| |
192| 3.34k| if (directed) {
------------------
| Branch (192:9): [True: 137, False: 3.20k]
------------------
193| 137| CHECK(fprintf(outstream, "digraph {\n"));
------------------
| | 37| 137|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 137]
| | | Branch (37:116): [Folded, False: 137]
| | ------------------
------------------
194| 3.20k| } else {
195| 3.20k| CHECK(fprintf(outstream, "graph {\n"));
------------------
| | 37| 3.20k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 3.20k]
| | | Branch (37:116): [Folded, False: 3.20k]
| | ------------------
------------------
196| 3.20k| }
197| |
198| | /* Write the graph attributes */
199| 3.34k| if (igraph_vector_int_size(>ypes) > 0) {
------------------
| Branch (199:9): [True: 549, False: 2.79k]
------------------
200| 549| CHECK(fprintf(outstream, " graph [\n"));
------------------
| | 37| 549|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 549]
| | | Branch (37:116): [Folded, False: 549]
| | ------------------
------------------
201| 1.39k| for (igraph_int_t i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (201:34): [True: 849, False: 549]
------------------
202| 849| const char *name;
203| 849| name = igraph_strvector_get(&gnames, i);
204| 849| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 656| 849| do { \
| | 657| 849| igraph_error_t igraph_i_ret = (expr); \
| | 658| 849| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 849| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 849]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 849| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 849]
| | ------------------
------------------
205| 849| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 849|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (205:17): [True: 110, False: 739]
------------------
206| 110| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 110| do { \
| | 657| 110| igraph_error_t igraph_i_ret = (expr); \
| | 658| 110| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 110| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 110]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 110| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 110]
| | ------------------
------------------
207| 110| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 110|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 110]
| | | Branch (37:116): [Folded, False: 110]
| | ------------------
------------------
208| 110| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 110| do { \
| | 657| 110| igraph_error_t igraph_i_ret = (expr); \
| | 658| 110| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 110| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 110]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 110| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 110]
| | ------------------
------------------
209| 110| CHECK(fputc('\n', outstream));
------------------
| | 37| 110|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 110]
| | | Branch (37:116): [Folded, False: 110]
| | ------------------
------------------
210| 739| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 739|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (210:24): [True: 599, False: 140]
------------------
211| 599| const char *s;
212| 599| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 599| do { \
| | 657| 599| igraph_error_t igraph_i_ret = (expr); \
| | 658| 599| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 599]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 599| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 599]
| | ------------------
------------------
213| 599| s = igraph_strvector_get(&strv, 0);
214| 599| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 599| do { \
| | 657| 599| igraph_error_t igraph_i_ret = (expr); \
| | 658| 599| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 599]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 599| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 599]
| | ------------------
------------------
215| 599| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 599|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 599]
| | | Branch (37:116): [Folded, False: 599]
| | ------------------
------------------
216| 599| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 140|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (216:24): [True: 140, False: 0]
------------------
217| 140| IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
------------------
| | 656| 140| do { \
| | 657| 140| igraph_error_t igraph_i_ret = (expr); \
| | 658| 140| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 140| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 140]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 140| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 140]
| | ------------------
------------------
218| 140| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 280|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:33): [True: 0, False: 140]
| | | Branch (37:42): [True: 0, False: 140]
| | | Branch (37:116): [Folded, False: 140]
| | ------------------
------------------
219| 140| IGRAPH_WARNING("Boolean graph attribute was converted to numeric.");
------------------
| | 797| 140| do { \
| | 798| 140| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 140| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 140]
| | ------------------
------------------
220| 140| } else {
221| 0| IGRAPH_WARNING("A non-numeric, non-string, non-boolean graph attribute was ignored.");
------------------
| | 797| 0| do { \
| | 798| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 0| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 0]
| | ------------------
------------------
222| 0| }
223| 849| }
224| 549| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 549|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 549]
| | | Branch (37:116): [Folded, False: 549]
| | ------------------
------------------
225| 549| }
226| |
227| | /* Write the vertices */
228| 3.34k| if (igraph_vector_int_size(&vtypes) > 0) {
------------------
| Branch (228:9): [True: 3.32k, False: 11]
------------------
229| 36.6k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (229:34): [True: 33.2k, False: 3.32k]
------------------
230| 33.2k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " [\n", i));
------------------
| | 37| 33.2k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 33.2k]
| | | Branch (37:116): [Folded, False: 33.2k]
| | ------------------
------------------
231| 85.9k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vtypes); j++) {
------------------
| Branch (231:38): [True: 52.6k, False: 33.2k]
------------------
232| 52.6k| const char *name;
233| 52.6k| name = igraph_strvector_get(&vnames, j);
234| 52.6k| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 656| 52.6k| do { \
| | 657| 52.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 52.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 52.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 52.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 52.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 52.6k]
| | ------------------
------------------
235| 52.6k| if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 52.6k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (235:21): [True: 5.33k, False: 47.2k]
------------------
236| 5.33k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name, igraph_vss_1(i), &numv));
------------------
| | 656| 5.33k| do { \
| | 657| 5.33k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.33k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.33k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.33k]
| | ------------------
------------------
237| 5.33k| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 5.33k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 5.33k]
| | | Branch (37:116): [Folded, False: 5.33k]
| | ------------------
------------------
238| 5.33k| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 5.33k| do { \
| | 657| 5.33k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.33k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.33k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.33k]
| | ------------------
------------------
239| 5.33k| CHECK(fputc('\n', outstream));
------------------
| | 37| 5.33k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 5.33k]
| | | Branch (37:116): [Folded, False: 5.33k]
| | ------------------
------------------
240| 47.2k| } else if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 47.2k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (240:28): [True: 42.8k, False: 4.44k]
------------------
241| 42.8k| const char *s;
242| 42.8k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name, igraph_vss_1(i), &strv));
------------------
| | 656| 42.8k| do { \
| | 657| 42.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 42.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.8k]
| | ------------------
------------------
243| 42.8k| s = igraph_strvector_get(&strv, 0);
244| 42.8k| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 42.8k| do { \
| | 657| 42.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 42.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.8k]
| | ------------------
------------------
245| 42.8k| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 42.8k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 42.8k]
| | | Branch (37:116): [Folded, False: 42.8k]
| | ------------------
------------------
246| 42.8k| } else if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 4.44k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (246:28): [True: 4.44k, False: 0]
------------------
247| 4.44k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name, igraph_vss_1(i), &boolv));
------------------
| | 656| 4.44k| do { \
| | 657| 4.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.44k]
| | ------------------
------------------
248| 4.44k| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 8.89k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:33): [True: 16, False: 4.43k]
| | | Branch (37:42): [True: 0, False: 4.44k]
| | | Branch (37:116): [Folded, False: 4.44k]
| | ------------------
------------------
249| 4.44k| IGRAPH_WARNING("A boolean vertex attribute was converted to numeric.");
------------------
| | 797| 4.44k| do { \
| | 798| 4.44k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 4.44k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 4.44k]
| | ------------------
------------------
250| 4.44k| } else {
251| 0| IGRAPH_WARNING("A non-numeric, non-string, non-boolean vertex attribute was ignored.");
------------------
| | 797| 0| do { \
| | 798| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 0| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 0]
| | ------------------
------------------
252| 0| }
253| 52.6k| }
254| 33.2k| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 33.2k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 33.2k]
| | | Branch (37:116): [Folded, False: 33.2k]
| | ------------------
------------------
255| 33.2k| }
256| 3.32k| } else {
257| 224| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (257:34): [True: 213, False: 11]
------------------
258| 213| CHECK(fprintf(outstream, " %" IGRAPH_PRId ";\n", i));
------------------
| | 37| 213|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 213]
| | | Branch (37:116): [Folded, False: 213]
| | ------------------
------------------
259| 213| }
260| 11| }
261| 3.34k| CHECK(fprintf(outstream, "\n"));
------------------
| | 37| 3.34k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 3.34k]
| | | Branch (37:116): [Folded, False: 3.34k]
| | ------------------
------------------
262| |
263| | /* Write the edges */
264| 3.34k| if (igraph_vector_int_size(&etypes) > 0) {
------------------
| Branch (264:9): [True: 1.63k, False: 1.70k]
------------------
265| 194k| for (igraph_int_t i = 0; i < no_of_edges; i++) {
------------------
| Branch (265:34): [True: 192k, False: 1.63k]
------------------
266| 192k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 192k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 192k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
267| 192k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 192k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 192k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
268| 192k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " %s %" IGRAPH_PRId " [\n", from, edgeop, to));
------------------
| | 37| 192k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 192k]
| | | Branch (37:116): [Folded, False: 192k]
| | ------------------
------------------
269| 652k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&etypes); j++) {
------------------
| Branch (269:38): [True: 460k, False: 192k]
------------------
270| 460k| const char *name;
271| 460k| name = igraph_strvector_get(&enames, j);
272| 460k| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 656| 460k| do { \
| | 657| 460k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 460k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 460k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 460k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 460k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 460k]
| | ------------------
------------------
273| 460k| if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 460k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (273:21): [True: 98.5k, False: 361k]
------------------
274| 98.5k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph,
------------------
| | 656| 98.5k| do { \
| | 657| 98.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 98.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 98.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 98.5k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 98.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 98.5k]
| | ------------------
------------------
275| 98.5k| name, igraph_ess_1(i), &numv));
276| 98.5k| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 98.5k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 98.5k]
| | | Branch (37:116): [Folded, False: 98.5k]
| | ------------------
------------------
277| 98.5k| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 98.5k| do { \
| | 657| 98.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 98.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 98.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 98.5k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 98.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 98.5k]
| | ------------------
------------------
278| 98.5k| CHECK(fputc('\n', outstream));
------------------
| | 37| 98.5k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 98.5k]
| | | Branch (37:116): [Folded, False: 98.5k]
| | ------------------
------------------
279| 361k| } else if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 361k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (279:28): [True: 354k, False: 6.71k]
------------------
280| 354k| const char *s;
281| 354k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph,
------------------
| | 656| 354k| do { \
| | 657| 354k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 354k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 354k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 354k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 354k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 354k]
| | ------------------
------------------
282| 354k| name, igraph_ess_1(i), &strv));
283| 354k| s = igraph_strvector_get(&strv, 0);
284| 354k| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 354k| do { \
| | 657| 354k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 354k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 354k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 354k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 354k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 354k]
| | ------------------
------------------
285| 354k| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 354k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 354k]
| | | Branch (37:116): [Folded, False: 354k]
| | ------------------
------------------
286| 354k| } else if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 6.71k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (286:28): [True: 6.71k, False: 0]
------------------
287| 6.71k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph,
------------------
| | 656| 6.71k| do { \
| | 657| 6.71k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.71k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.71k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.71k]
| | ------------------
------------------
288| 6.71k| name, igraph_ess_1(i), &boolv));
289| 6.71k| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 13.4k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:33): [True: 0, False: 6.71k]
| | | Branch (37:42): [True: 0, False: 6.71k]
| | | Branch (37:116): [Folded, False: 6.71k]
| | ------------------
------------------
290| 6.71k| IGRAPH_WARNING("A boolean edge attribute was converted to numeric.");
------------------
| | 797| 6.71k| do { \
| | 798| 6.71k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 6.71k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 6.71k]
| | ------------------
------------------
291| 6.71k| } else {
292| 0| IGRAPH_WARNING("A non-numeric, non-string graph attribute ignored.");
------------------
| | 797| 0| do { \
| | 798| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 0| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 0]
| | ------------------
------------------
293| 0| }
294| 460k| }
295| 192k| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 192k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 192k]
| | | Branch (37:116): [Folded, False: 192k]
| | ------------------
------------------
296| 192k| }
297| 1.70k| } else {
298| 154k| for (igraph_int_t i = 0; i < no_of_edges; i++) {
------------------
| Branch (298:34): [True: 152k, False: 1.70k]
------------------
299| 152k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 152k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 152k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
300| 152k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 152k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 152k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
301| 152k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " %s %" IGRAPH_PRId ";\n", from, edgeop, to));
------------------
| | 37| 152k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 152k]
| | | Branch (37:116): [Folded, False: 152k]
| | ------------------
------------------
302| 152k| }
303| 1.70k| }
304| 3.34k| CHECK(fprintf(outstream, "}\n"));
------------------
| | 37| 3.34k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 3.34k]
| | | Branch (37:116): [Folded, False: 3.34k]
| | ------------------
------------------
305| |
306| 3.34k| igraph_vector_char_destroy(&buf2);
307| 3.34k| igraph_vector_char_destroy(&buf);
308| 3.34k| igraph_vector_bool_destroy(&boolv);
309| 3.34k| igraph_strvector_destroy(&strv);
310| 3.34k| igraph_vector_destroy(&numv);
311| 3.34k| igraph_vector_int_destroy(&etypes);
312| 3.34k| igraph_vector_int_destroy(&vtypes);
313| 3.34k| igraph_vector_int_destroy(>ypes);
314| 3.34k| igraph_strvector_destroy(&enames);
315| 3.34k| igraph_strvector_destroy(&vnames);
316| 3.34k| igraph_strvector_destroy(&gnames);
317| 3.34k| IGRAPH_FINALLY_CLEAN(11);
318| |
319| 3.34k| return IGRAPH_SUCCESS;
320| 3.34k|}
dot.c:dot_escape:
39| 1.01M|static igraph_error_t dot_escape(const char *orig, igraph_vector_char_t* result) {
40| | /* do we have to escape the string at all? */
41| 1.01M| igraph_int_t i, j, len = strlen(orig), newlen = 0;
42| 1.01M| igraph_bool_t need_quote = false, is_number = true;
43| |
44| | /* first, check whether the string is equal to some reserved word, or empty */
45| 1.01M| if (!strcasecmp(orig, "graph") || !strcasecmp(orig, "digraph") ||
------------------
| Branch (45:9): [True: 198, False: 1.01M]
| Branch (45:39): [True: 98, False: 1.01M]
------------------
46| 1.01M| !strcasecmp(orig, "node") || !strcasecmp(orig, "edge") ||
------------------
| Branch (46:9): [True: 195, False: 1.01M]
| Branch (46:38): [True: 199, False: 1.01M]
------------------
47| 1.01M| !strcasecmp(orig, "strict") || !strcasecmp(orig, "subgraph") || len == 0) {
------------------
| Branch (47:9): [True: 196, False: 1.01M]
| Branch (47:40): [True: 3.42k, False: 1.00M]
| Branch (47:73): [True: 112k, False: 893k]
------------------
48| 117k| need_quote = true;
49| 117k| is_number = false;
50| 117k| }
51| |
52| | /* next, check whether we need to escape the string for any other reason.
53| | * Also update is_number and newlen */
54| 247M| for (i = 0; i < len; i++) {
------------------
| Branch (54:17): [True: 246M, False: 1.01M]
------------------
55| 246M| if (isdigit(orig[i])) {
------------------
| Branch (55:13): [True: 5.74M, False: 240M]
------------------
56| 5.74M| newlen++;
57| 240M| } else if (orig[i] == '-' && i == 0) {
------------------
| Branch (57:20): [True: 2.62M, False: 237M]
| Branch (57:38): [True: 3.59k, False: 2.62M]
------------------
58| 3.59k| newlen++;
59| 240M| } else if (orig[i] == '.') {
------------------
| Branch (59:20): [True: 937k, False: 239M]
------------------
60| 937k| if (is_number) {
------------------
| Branch (60:17): [True: 6.66k, False: 930k]
------------------
61| 6.66k| newlen++;
62| 930k| } else {
63| 930k| need_quote = true;
64| 930k| newlen++;
65| 930k| }
66| 239M| } else if (orig[i] == '_') {
------------------
| Branch (66:20): [True: 4.03M, False: 235M]
------------------
67| 4.03M| is_number = false; newlen++;
68| 235M| } else if (orig[i] == '\\' || orig[i] == '"' || orig[i] == '\n') {
------------------
| Branch (68:20): [True: 11.8k, False: 235M]
| Branch (68:39): [True: 14.1M, False: 221M]
| Branch (68:57): [True: 10.9M, False: 210M]
------------------
69| 25.1M| need_quote = true; is_number = false; newlen += 2; /* will be escaped */
70| 210M| } else if (isalpha(orig[i])) {
------------------
| Branch (70:20): [True: 46.3M, False: 163M]
------------------
71| 46.3M| is_number = false; newlen++;
72| 163M| } else {
73| 163M| is_number = false; need_quote = true; newlen++;
74| 163M| }
75| 246M| }
76| 1.01M| if (is_number && len > 0 && orig[len - 1] == '.') {
------------------
| Branch (76:9): [True: 5.48k, False: 1.00M]
| Branch (76:22): [True: 5.48k, False: 0]
| Branch (76:33): [True: 263, False: 5.22k]
------------------
77| 263| is_number = false;
78| 263| }
79| 1.01M| if (!is_number && isdigit(orig[0])) {
------------------
| Branch (79:9): [True: 1.00M, False: 5.22k]
| Branch (79:23): [True: 3.41k, False: 1.00M]
------------------
80| 3.41k| need_quote = true;
81| 3.41k| }
82| |
83| 1.01M| if (is_number || !need_quote) {
------------------
| Branch (83:9): [True: 5.22k, False: 1.00M]
| Branch (83:22): [True: 845k, False: 160k]
------------------
84| 850k| IGRAPH_CHECK(igraph_vector_char_resize(result, newlen + 1));
------------------
| | 656| 850k| do { \
| | 657| 850k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 850k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 850k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 850k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 850k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 850k]
| | ------------------
------------------
85| 850k| memcpy(VECTOR(*result), orig, newlen);
------------------
| | 60| 850k|#define VECTOR(v) ((v).stor_begin)
------------------
86| 850k| } else {
87| 160k| newlen += 2;
88| 160k| IGRAPH_CHECK(igraph_vector_char_resize(result, newlen + 1));
------------------
| | 656| 160k| do { \
| | 657| 160k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 160k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 160k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 160k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 160k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 160k]
| | ------------------
------------------
89| 160k| VECTOR(*result)[0] = '"';
------------------
| | 60| 160k|#define VECTOR(v) ((v).stor_begin)
------------------
90| 160k| VECTOR(*result)[newlen - 1] = '"';
------------------
| | 60| 160k|#define VECTOR(v) ((v).stor_begin)
------------------
91| |
92| | /* Escape quotes, backslashes and newlines.
93| | * Even though the format spec at https://graphviz.org/doc/info/lang.html
94| | * claims that only quotes need escaping, escaping backslashes appears to
95| | * be necessary as well for GraphViz to render labels correctly.
96| | * Tested with GraphViz 2.50. */
97| 230M| for (i = 0, j = 1; i < len; i++) {
------------------
| Branch (97:28): [True: 230M, False: 160k]
------------------
98| 230M| if (orig[i] == '\n') {
------------------
| Branch (98:17): [True: 10.9M, False: 219M]
------------------
99| 10.9M| VECTOR(*result)[j++] = '\\';
------------------
| | 60| 10.9M|#define VECTOR(v) ((v).stor_begin)
------------------
100| 10.9M| VECTOR(*result)[j++] = 'n';
------------------
| | 60| 10.9M|#define VECTOR(v) ((v).stor_begin)
------------------
101| 10.9M| continue;
102| 10.9M| }
103| 219M| if (orig[i] == '\\' || orig[i] == '"') {
------------------
| Branch (103:17): [True: 11.8k, False: 219M]
| Branch (103:36): [True: 14.1M, False: 205M]
------------------
104| 14.1M| VECTOR(*result)[j++] = '\\';
------------------
| | 60| 14.1M|#define VECTOR(v) ((v).stor_begin)
------------------
105| 14.1M| }
106| 219M| VECTOR(*result)[j++] = orig[i];
------------------
| | 60| 219M|#define VECTOR(v) ((v).stor_begin)
------------------
107| 219M| }
108| 160k| }
109| 1.01M| VECTOR(*result)[newlen] = 0;
------------------
| | 60| 1.01M|#define VECTOR(v) ((v).stor_begin)
------------------
110| |
111| 1.01M| return IGRAPH_SUCCESS;
112| 1.01M|}
dot.c:fprint_integral_or_precise:
117| 103k|static igraph_error_t fprint_integral_or_precise(FILE *file, igraph_real_t x, igraph_vector_char_t *buf) {
118| 103k| if (fabs(x) <= IGRAPH_MAX_EXACT_REAL && floor(x) == x) {
------------------
| | 35| 207k|#define IGRAPH_MAX_EXACT_REAL ((double)(1LL << DBL_MANT_DIG))
------------------
| Branch (118:9): [True: 5.40k, False: 98.5k]
| Branch (118:45): [True: 4.71k, False: 688]
------------------
119| | /* write exactly representable integral values in standard integer notation;
120| | * the above conditional skips +-Inf and NaN */
121| 4.71k| CHECK(fprintf(file, "%.f", x));
------------------
| | 37| 4.71k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 4.71k]
| | | Branch (37:116): [Folded, False: 4.71k]
| | ------------------
------------------
122| 99.2k| } else {
123| | /* write as precise float and quote if necessary */
124| 99.2k| char str[50]; /* large enough to hold any precisely printed real */
125| 99.2k| CHECK(igraph_real_snprintf_precise(str, sizeof(str) / sizeof(str[0]), x));
------------------
| | 37| 99.2k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 99.2k]
| | | Branch (37:116): [Folded, False: 99.2k]
| | ------------------
------------------
126| 99.2k| IGRAPH_CHECK(dot_escape(str, buf));
------------------
| | 656| 99.2k| do { \
| | 657| 99.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 99.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 99.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 99.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 99.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 99.2k]
| | ------------------
------------------
127| 99.2k| CHECK(fputs(VECTOR(*buf), file));
------------------
| | 37| 99.2k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (37:42): [True: 0, False: 99.2k]
| | | Branch (37:116): [Folded, False: 99.2k]
| | ------------------
------------------
128| 99.2k| }
129| 103k| return IGRAPH_SUCCESS;
130| 103k|}
igraph_gml_tree_init_integer:
31| 743k| igraph_int_t value) {
32| |
33| 743k| igraph_int_t *p;
34| |
35| 743k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 743k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 743k| do { \
| | | | 657| 743k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 743k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 743k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 743k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 743k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 743k]
| | | | ------------------
| | ------------------
| | 47| 743k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 743k| do { \
| | | | 604| 743k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 743k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 743k| * incorrect destructor function with the pointer */ \
| | | | 607| 743k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 743k]
| | | | ------------------
| | | | 608| 743k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 743k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 743k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 743k]
| | ------------------
------------------
36| 743k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 743k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 743k| do { \
| | | | 657| 743k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 743k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 743k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 743k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 743k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 743k]
| | | | ------------------
| | ------------------
| | 115| 743k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 743k| do { \
| | | | 604| 743k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 743k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 743k| * incorrect destructor function with the pointer */ \
| | | | 607| 743k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 743k]
| | | | ------------------
| | | | 608| 743k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 743k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 743k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 743k]
| | ------------------
------------------
37| 743k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 743k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 743k| do { \
| | | | 657| 743k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 743k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 743k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 743k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 743k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 743k]
| | | | ------------------
| | ------------------
| | 47| 743k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 743k| do { \
| | | | 604| 743k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 743k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 743k| * incorrect destructor function with the pointer */ \
| | | | 607| 743k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 743k]
| | | | ------------------
| | | | 608| 743k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 743k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 743k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 743k]
| | ------------------
------------------
38| 743k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 743k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 743k| do { \
| | | | 657| 743k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 743k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 743k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 743k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 743k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 743k]
| | | | ------------------
| | ------------------
| | 120| 743k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 743k| do { \
| | | | 604| 743k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 743k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 743k| * incorrect destructor function with the pointer */ \
| | | | 607| 743k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 743k]
| | | | ------------------
| | | | 608| 743k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 743k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 743k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 743k]
| | ------------------
------------------
39| |
40| | /* names */
41| 743k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 743k|#define VECTOR(v) ((v).stor_begin)
------------------
42| |
43| | /* line number */
44| 743k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 743k|#define VECTOR(v) ((v).stor_begin)
------------------
45| |
46| | /* types */
47| 743k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_INTEGER;
------------------
| | 60| 743k|#define VECTOR(v) ((v).stor_begin)
------------------
48| |
49| | /* children */
50| 743k| p = IGRAPH_CALLOC(1, igraph_int_t);
------------------
| | 33| 743k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.48M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 743k, Folded]
| | | | ------------------
| | ------------------
------------------
51| 743k| IGRAPH_CHECK_OOM(p, "Cannot create integer GML tree node.");
------------------
| | 709| 743k| do { \
| | 710| 743k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 743k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 743k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 743k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 743k]
| | ------------------
------------------
52| 743k| *p = value;
53| 743k| VECTOR(t->children)[0] = p;
------------------
| | 60| 743k|#define VECTOR(v) ((v).stor_begin)
------------------
54| |
55| 743k| IGRAPH_FINALLY_CLEAN(4);
56| 743k| return IGRAPH_SUCCESS;
57| 743k|}
igraph_gml_tree_init_real:
62| 901| igraph_real_t value) {
63| |
64| 901| igraph_real_t *p;
65| |
66| 901| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 901| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 901| do { \
| | | | 657| 901| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 901| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 901| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 901]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 901| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 901]
| | | | ------------------
| | ------------------
| | 47| 901| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 901| do { \
| | | | 604| 901| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 901| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 901| * incorrect destructor function with the pointer */ \
| | | | 607| 901| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 901]
| | | | ------------------
| | | | 608| 901| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 901| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 901]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 901]
| | ------------------
------------------
67| 901| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 901| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 901| do { \
| | | | 657| 901| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 901| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 901| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 901]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 901| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 901]
| | | | ------------------
| | ------------------
| | 115| 901| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 901| do { \
| | | | 604| 901| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 901| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 901| * incorrect destructor function with the pointer */ \
| | | | 607| 901| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 901]
| | | | ------------------
| | | | 608| 901| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 901| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 901]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 901]
| | ------------------
------------------
68| 901| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 901| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 901| do { \
| | | | 657| 901| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 901| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 901| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 901]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 901| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 901]
| | | | ------------------
| | ------------------
| | 47| 901| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 901| do { \
| | | | 604| 901| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 901| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 901| * incorrect destructor function with the pointer */ \
| | | | 607| 901| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 901]
| | | | ------------------
| | | | 608| 901| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 901| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 901]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 901]
| | ------------------
------------------
69| 901| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 901| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 901| do { \
| | | | 657| 901| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 901| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 901| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 901]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 901| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 901]
| | | | ------------------
| | ------------------
| | 120| 901| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 901| do { \
| | | | 604| 901| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 901| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 901| * incorrect destructor function with the pointer */ \
| | | | 607| 901| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 901]
| | | | ------------------
| | | | 608| 901| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 901| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 901]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 901]
| | ------------------
------------------
70| |
71| | /* names */
72| 901| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 901|#define VECTOR(v) ((v).stor_begin)
------------------
73| |
74| | /* line number */
75| 901| VECTOR(t->lines)[0] = line;
------------------
| | 60| 901|#define VECTOR(v) ((v).stor_begin)
------------------
76| |
77| | /* types */
78| 901| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_REAL;
------------------
| | 60| 901|#define VECTOR(v) ((v).stor_begin)
------------------
79| |
80| | /* children */
81| 901| p = IGRAPH_CALLOC(1, igraph_real_t);
------------------
| | 33| 901|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.80k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 901, Folded]
| | | | ------------------
| | ------------------
------------------
82| 901| IGRAPH_CHECK_OOM(p, "Cannot create real GML tree node.");
------------------
| | 709| 901| do { \
| | 710| 901| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 901| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 901]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 901| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 901]
| | ------------------
------------------
83| 901| *p = value;
84| 901| VECTOR(t->children)[0] = p;
------------------
| | 60| 901|#define VECTOR(v) ((v).stor_begin)
------------------
85| |
86| 901| IGRAPH_FINALLY_CLEAN(4);
87| 901| return IGRAPH_SUCCESS;
88| 901|}
igraph_gml_tree_init_string:
93| 370k| const char *value) {
94| |
95| 370k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 370k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 370k| do { \
| | | | 657| 370k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 370k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 370k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 370k]
| | | | ------------------
| | ------------------
| | 47| 370k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 370k| do { \
| | | | 604| 370k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 370k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 370k| * incorrect destructor function with the pointer */ \
| | | | 607| 370k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 370k]
| | | | ------------------
| | | | 608| 370k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 370k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 370k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 370k]
| | ------------------
------------------
96| 370k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 370k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 370k| do { \
| | | | 657| 370k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 370k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 370k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 370k]
| | | | ------------------
| | ------------------
| | 115| 370k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 370k| do { \
| | | | 604| 370k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 370k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 370k| * incorrect destructor function with the pointer */ \
| | | | 607| 370k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 370k]
| | | | ------------------
| | | | 608| 370k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 370k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 370k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 370k]
| | ------------------
------------------
97| 370k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 370k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 370k| do { \
| | | | 657| 370k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 370k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 370k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 370k]
| | | | ------------------
| | ------------------
| | 47| 370k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 370k| do { \
| | | | 604| 370k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 370k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 370k| * incorrect destructor function with the pointer */ \
| | | | 607| 370k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 370k]
| | | | ------------------
| | | | 608| 370k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 370k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 370k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 370k]
| | ------------------
------------------
98| 370k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 370k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 370k| do { \
| | | | 657| 370k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 370k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 370k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 370k]
| | | | ------------------
| | ------------------
| | 120| 370k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 370k| do { \
| | | | 604| 370k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 370k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 370k| * incorrect destructor function with the pointer */ \
| | | | 607| 370k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 370k]
| | | | ------------------
| | | | 608| 370k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 370k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 370k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 370k]
| | ------------------
------------------
99| |
100| | /* names */
101| 370k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 370k|#define VECTOR(v) ((v).stor_begin)
------------------
102| |
103| | /* line number */
104| 370k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 370k|#define VECTOR(v) ((v).stor_begin)
------------------
105| |
106| | /* types */
107| 370k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_STRING;
------------------
| | 60| 370k|#define VECTOR(v) ((v).stor_begin)
------------------
108| |
109| | /* children */
110| 370k| VECTOR(t->children)[0] = (void*) value;
------------------
| | 60| 370k|#define VECTOR(v) ((v).stor_begin)
------------------
111| |
112| 370k| IGRAPH_FINALLY_CLEAN(4);
113| 370k| return IGRAPH_SUCCESS;
114| 370k|}
igraph_gml_tree_init_tree:
119| 381k| igraph_gml_tree_t *value) {
120| |
121| 381k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 381k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 381k| do { \
| | | | 657| 381k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 381k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 381k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 381k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 381k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 381k]
| | | | ------------------
| | ------------------
| | 47| 381k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 381k| do { \
| | | | 604| 381k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 381k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 381k| * incorrect destructor function with the pointer */ \
| | | | 607| 381k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 381k]
| | | | ------------------
| | | | 608| 381k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 381k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 381k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 381k]
| | ------------------
------------------
122| 381k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 381k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 381k| do { \
| | | | 657| 381k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 381k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 381k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 381k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 381k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 381k]
| | | | ------------------
| | ------------------
| | 115| 381k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 381k| do { \
| | | | 604| 381k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 381k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 381k| * incorrect destructor function with the pointer */ \
| | | | 607| 381k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 381k]
| | | | ------------------
| | | | 608| 381k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 381k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 381k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 381k]
| | ------------------
------------------
123| 381k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 381k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 381k| do { \
| | | | 657| 381k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 381k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 381k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 381k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 381k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 381k]
| | | | ------------------
| | ------------------
| | 47| 381k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 381k| do { \
| | | | 604| 381k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 381k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 381k| * incorrect destructor function with the pointer */ \
| | | | 607| 381k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 381k]
| | | | ------------------
| | | | 608| 381k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 381k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 381k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 381k]
| | ------------------
------------------
124| 381k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 381k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 381k| do { \
| | | | 657| 381k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 381k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 381k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 381k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 381k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 381k]
| | | | ------------------
| | ------------------
| | 120| 381k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 381k| do { \
| | | | 604| 381k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 381k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 381k| * incorrect destructor function with the pointer */ \
| | | | 607| 381k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 381k]
| | | | ------------------
| | | | 608| 381k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 381k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 381k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 381k]
| | ------------------
------------------
125| |
126| | /* names */
127| 381k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 381k|#define VECTOR(v) ((v).stor_begin)
------------------
128| |
129| | /* line number */
130| 381k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 381k|#define VECTOR(v) ((v).stor_begin)
------------------
131| |
132| | /* types */
133| 381k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_TREE;
------------------
| | 60| 381k|#define VECTOR(v) ((v).stor_begin)
------------------
134| |
135| | /* children */
136| 381k| VECTOR(t->children)[0] = value;
------------------
| | 60| 381k|#define VECTOR(v) ((v).stor_begin)
------------------
137| |
138| 381k| IGRAPH_FINALLY_CLEAN(4);
139| 381k| return IGRAPH_SUCCESS;
140| |
141| 381k|}
igraph_gml_tree_mergedest:
153| 1.11M|igraph_error_t igraph_gml_tree_mergedest(igraph_gml_tree_t *t1, igraph_gml_tree_t *t2) {
154| 1.11M| igraph_int_t i, n = igraph_vector_ptr_size(&t2->children);
155| |
156| 2.22M| for (i = 0; i < n; i++) {
------------------
| Branch (156:17): [True: 1.11M, False: 1.11M]
------------------
157| 1.11M| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t1->names, VECTOR(t2->names)[i]));
------------------
| | 656| 1.11M| do { \
| | 657| 1.11M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.11M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.11M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.11M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.11M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.11M]
| | ------------------
------------------
158| 1.11M| IGRAPH_CHECK(igraph_vector_char_push_back(&t1->types, VECTOR(t2->types)[i]));
------------------
| | 656| 1.11M| do { \
| | 657| 1.11M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.11M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.11M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.11M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.11M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.11M]
| | ------------------
------------------
159| 1.11M| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t1->children, VECTOR(t2->children)[i]));
------------------
| | 656| 1.11M| do { \
| | 657| 1.11M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.11M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.11M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.11M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.11M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.11M]
| | ------------------
------------------
160| 1.11M| IGRAPH_CHECK(igraph_vector_int_push_back(&t1->lines, VECTOR(t2->lines)[i]));
------------------
| | 656| 1.11M| do { \
| | 657| 1.11M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.11M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.11M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.11M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.11M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.11M]
| | ------------------
------------------
161| 1.11M| }
162| |
163| 1.11M| igraph_vector_ptr_destroy(&t2->names);
164| 1.11M| igraph_vector_char_destroy(&t2->types);
165| 1.11M| igraph_vector_ptr_destroy(&t2->children);
166| 1.11M| igraph_vector_int_destroy(&t2->lines);
167| |
168| 1.11M| return IGRAPH_SUCCESS;
169| 1.11M|}
igraph_gml_tree_destroy:
171| 385k|void igraph_gml_tree_destroy(igraph_gml_tree_t *t) {
172| |
173| 385k| igraph_int_t i, n = igraph_vector_ptr_size(&t->children);
174| 1.88M| for (i = 0; i < n; i++) {
------------------
| Branch (174:17): [True: 1.49M, False: 385k]
------------------
175| 1.49M| igraph_i_gml_tree_type_t type = (igraph_i_gml_tree_type_t) VECTOR(t->types)[i];
------------------
| | 60| 1.49M|#define VECTOR(v) ((v).stor_begin)
------------------
176| 1.49M| switch (type) {
------------------
| Branch (176:17): [True: 1.49M, False: 0]
------------------
177| 381k| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (177:9): [True: 381k, False: 1.11M]
------------------
178| 381k| igraph_gml_tree_destroy(VECTOR(t->children)[i]);
------------------
| | 60| 381k|#define VECTOR(v) ((v).stor_begin)
------------------
179| 381k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 381k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
180| 381k| break;
181| 743k| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (181:9): [True: 743k, False: 752k]
------------------
182| 743k| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 743k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
183| 743k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 743k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
184| 743k| break;
185| 901| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (185:9): [True: 901, False: 1.49M]
------------------
186| 901| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 901|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
187| 901| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 901|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
188| 901| break;
189| 370k| case IGRAPH_I_GML_TREE_STRING:
------------------
| Branch (189:9): [True: 370k, False: 1.12M]
------------------
190| 370k| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 370k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
191| 370k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 370k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
192| 370k| break;
193| 0| case IGRAPH_I_GML_TREE_DELETED:
------------------
| Branch (193:9): [True: 0, False: 1.49M]
------------------
194| 0| break;
195| 1.49M| }
196| 1.49M| }
197| 385k| igraph_vector_ptr_destroy(&t->names);
198| 385k| igraph_vector_char_destroy(&t->types);
199| 385k| igraph_vector_ptr_destroy(&t->children);
200| 385k| igraph_vector_int_destroy(&t->lines);
201| | IGRAPH_FREE(t);
------------------
| | 36| 385k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
202| 385k|}
igraph_gml_tree_length:
204| 3.73M|igraph_int_t igraph_gml_tree_length(const igraph_gml_tree_t *t) {
205| 3.73M| return igraph_vector_ptr_size(&t->names);
206| 3.73M|}
igraph_gml_tree_find:
210| 730k|) {
211| 730k| igraph_int_t size = igraph_vector_ptr_size(&t->names);
212| 1.08M| while ( from < size && (! VECTOR(t->names)[from] ||
------------------
| | 60| 1.08M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (212:13): [True: 1.08M, False: 0]
| Branch (212:29): [True: 0, False: 1.08M]
------------------
213| 1.08M| strcmp(VECTOR(t->names)[from], name)) ) {
------------------
| | 60| 1.08M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (213:29): [True: 354k, False: 730k]
------------------
214| 354k| from++;
215| 354k| }
216| |
217| 730k| if (from == size) {
------------------
| Branch (217:9): [True: 0, False: 730k]
------------------
218| 0| from = -1;
219| 0| }
220| 730k| return from;
221| 730k|}
igraph_gml_tree_type:
234| 1.90M|igraph_i_gml_tree_type_t igraph_gml_tree_type(const igraph_gml_tree_t *t, igraph_int_t pos) {
235| 1.90M| return (igraph_i_gml_tree_type_t) VECTOR(t->types)[pos];
------------------
| | 60| 1.90M|#define VECTOR(v) ((v).stor_begin)
------------------
236| 1.90M|}
igraph_gml_tree_name:
238| 2.97M|const char *igraph_gml_tree_name(const igraph_gml_tree_t *t, igraph_int_t pos) {
239| 2.97M| return VECTOR(t->names)[pos];
------------------
| | 60| 2.97M|#define VECTOR(v) ((v).stor_begin)
------------------
240| 2.97M|}
igraph_gml_tree_get_integer:
247| 810k| igraph_int_t pos) {
248| 810k| igraph_int_t *i = VECTOR(t->children)[pos];
------------------
| | 60| 810k|#define VECTOR(v) ((v).stor_begin)
------------------
249| 810k| return *i;
250| 810k|}
igraph_gml_tree_get_real:
253| 901| igraph_int_t pos) {
254| 901| igraph_real_t *d = VECTOR(t->children)[pos];
------------------
| | 60| 901|#define VECTOR(v) ((v).stor_begin)
------------------
255| 901| return *d;
256| 901|}
igraph_gml_tree_get_string:
259| 366k| igraph_int_t pos) {
260| 366k| const char *s = VECTOR(t->children)[pos];
------------------
| | 60| 366k|#define VECTOR(v) ((v).stor_begin)
------------------
261| 366k| return s;
262| 366k|}
igraph_gml_tree_get_tree:
265| 760k| igraph_int_t pos) {
266| 760k| igraph_gml_tree_t *tree = VECTOR(t->children)[pos];
------------------
| | 60| 760k|#define VECTOR(v) ((v).stor_begin)
------------------
267| 760k| return tree;
268| 760k|}
igraph_i_gml_parsedata_init:
212| 3.34k|igraph_error_t igraph_i_gml_parsedata_init(igraph_i_gml_parsedata_t *context) {
213| 3.34k| context->depth = 0;
214| 3.34k| context->scanner = NULL;
215| 3.34k| context->tree = NULL;
216| 3.34k| context->errmsg[0] = '\0';
217| 3.34k| context->igraph_errno = IGRAPH_SUCCESS;
218| |
219| 3.34k| return IGRAPH_SUCCESS;
220| 3.34k|}
igraph_i_gml_parsedata_destroy:
222| 3.34k|void igraph_i_gml_parsedata_destroy(igraph_i_gml_parsedata_t *context) {
223| 3.34k| if (context->tree != NULL) {
------------------
| Branch (223:9): [True: 3.34k, False: 0]
------------------
224| 3.34k| igraph_gml_tree_destroy(context->tree);
225| 3.34k| context->tree = NULL;
226| 3.34k| }
227| |
228| 3.34k| if (context->scanner != NULL) {
------------------
| Branch (228:9): [True: 3.34k, False: 0]
------------------
229| 3.34k| (void) igraph_gml_yylex_destroy(context->scanner);
230| | context->scanner = NULL;
231| 3.34k| }
232| 3.34k|}
igraph_read_graph_gml:
386| 3.34k|igraph_error_t igraph_read_graph_gml(igraph_t *graph, FILE *instream) {
387| |
388| 3.34k| igraph_int_t i;
389| 3.34k| igraph_int_t no_of_nodes = 0, no_of_edges = 0;
390| 3.34k| igraph_int_t node_no;
391| 3.34k| igraph_trie_t trie;
392| 3.34k| igraph_vector_int_t edges;
393| 3.34k| igraph_bool_t directed = IGRAPH_UNDIRECTED;
394| 3.34k| igraph_bool_t has_directed = false;
395| 3.34k| igraph_gml_tree_t *gtree;
396| 3.34k| igraph_int_t gidx;
397| 3.34k| igraph_trie_t vattrnames;
398| 3.34k| igraph_trie_t eattrnames;
399| 3.34k| igraph_trie_t gattrnames;
400| 3.34k| igraph_attribute_record_list_t gattrs, vattrs, eattrs;
401| 3.34k| igraph_attribute_record_list_t *attrs[3];
402| 3.34k| igraph_int_t edgeptr = 0;
403| 3.34k| igraph_i_gml_parsedata_t context;
404| 3.34k| igraph_bool_t entity_warned = false; /* used to warn at most once about unsupported entities */
405| |
406| 3.34k| attrs[0] = &gattrs; attrs[1] = &vattrs; attrs[2] = &eattrs;
407| |
408| 3.34k| IGRAPH_CHECK(igraph_i_gml_parsedata_init(&context));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
409| 3.34k| IGRAPH_FINALLY(igraph_i_gml_parsedata_destroy, &context);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
410| |
411| 3.34k| igraph_gml_yylex_init_extra(&context, &context.scanner);
412| |
413| 3.34k| igraph_gml_yyset_in(instream, context.scanner);
414| |
415| | /* Protect 'context' from being destroyed before returning from yyparse() */
416| 3.34k| IGRAPH_FINALLY_ENTER();
417| 3.34k| int err = igraph_gml_yyparse(&context);
418| 3.34k| IGRAPH_FINALLY_EXIT();
419| 3.34k| switch (err) {
420| 3.34k| case 0: /* success */
------------------
| Branch (420:5): [True: 3.34k, False: 0]
------------------
421| 3.34k| break;
422| 0| case 1: /* parse error */
------------------
| Branch (422:5): [True: 0, False: 3.34k]
------------------
423| 0| if (context.errmsg[0] != '\0') {
------------------
| Branch (423:13): [True: 0, False: 0]
------------------
424| 0| IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
425| 0| } else if (context.igraph_errno != IGRAPH_SUCCESS) {
------------------
| Branch (425:20): [True: 0, False: 0]
------------------
426| 0| IGRAPH_ERROR("", context.igraph_errno);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
427| 0| } else {
428| 0| IGRAPH_ERROR("Cannot read GML file.", IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
429| 0| }
430| 0| break;
431| 0| case 2: /* out of memory */
------------------
| Branch (431:5): [True: 0, False: 3.34k]
------------------
432| 0| IGRAPH_ERROR("Cannot read GML file.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
433| 0| break;
434| 0| default: /* must never reach here */
------------------
| Branch (434:5): [True: 0, False: 3.34k]
------------------
435| | /* Hint: This will usually be triggered if an IGRAPH_CHECK() is used in a Bison
436| | * action instead of an IGRAPH_YY_CHECK(), resulting in an igraph errno being
437| | * returned in place of a Bison error code.
438| | * TODO: What if future Bison versions introduce error codes other than 0, 1 and 2?
439| | */
440| 0| IGRAPH_FATALF("Parser returned unexpected error code (%d) when reading GML file.", err); /* LCOV_EXCL_LINE */
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
441| 3.34k| }
442| |
443| | /* Check version, if present, integer and not '1' then ignored */
444| 3.34k| i = igraph_gml_tree_find(context.tree, "Version", 0);
445| 3.34k| if (i >= 0 &&
------------------
| Branch (445:9): [True: 3.34k, False: 0]
------------------
446| 3.34k| igraph_gml_tree_type(context.tree, i) == IGRAPH_I_GML_TREE_INTEGER &&
------------------
| Branch (446:9): [True: 3.34k, False: 0]
------------------
447| 3.34k| igraph_gml_tree_get_integer(context.tree, i) != 1) {
------------------
| Branch (447:9): [True: 0, False: 3.34k]
------------------
448| 0| IGRAPH_WARNINGF("Unknown GML version: %" IGRAPH_PRId ". "
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
449| 0| "Parsing will continue assuming GML version 1, but may fail.",
450| 0| igraph_gml_tree_get_integer(context.tree, i));
451| 0| }
452| |
453| | /* Get the graph */
454| 3.34k| gidx = igraph_gml_tree_find(context.tree, "graph", 0);
455| 3.34k| if (gidx == -1) {
------------------
| Branch (455:9): [True: 0, False: 3.34k]
------------------
456| 0| IGRAPH_ERROR("No 'graph' object in GML file.", IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
457| 0| }
458| 3.34k| if (igraph_gml_tree_type(context.tree, gidx) !=
------------------
| Branch (458:9): [True: 0, False: 3.34k]
------------------
459| 3.34k| IGRAPH_I_GML_TREE_TREE) {
460| 0| IGRAPH_ERRORF("Invalid type for 'graph' object in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
461| 0| igraph_gml_tree_line(context.tree, gidx));
462| 0| }
463| 3.34k| gtree = igraph_gml_tree_get_tree(context.tree, gidx);
464| |
465| 3.34k| IGRAPH_CHECK(igraph_attribute_record_list_init(&gattrs, 0));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
466| 3.34k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &gattrs);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
467| 3.34k| IGRAPH_CHECK(igraph_attribute_record_list_init(&vattrs, 0));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
468| 3.34k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &vattrs);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
469| 3.34k| IGRAPH_CHECK(igraph_attribute_record_list_init(&eattrs, 0));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
470| 3.34k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &eattrs);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
471| |
472| 3.34k| IGRAPH_TRIE_INIT_FINALLY(&trie, 0);
------------------
| | 55| 3.34k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 56| 3.34k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.34k]
| | ------------------
------------------
473| 3.34k| IGRAPH_TRIE_INIT_FINALLY(&vattrnames, 0);
------------------
| | 55| 3.34k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 56| 3.34k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.34k]
| | ------------------
------------------
474| 3.34k| IGRAPH_TRIE_INIT_FINALLY(&eattrnames, 0);
------------------
| | 55| 3.34k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 56| 3.34k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.34k]
| | ------------------
------------------
475| 3.34k| IGRAPH_TRIE_INIT_FINALLY(&gattrnames, 0);
------------------
| | 55| 3.34k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 56| 3.34k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.34k]
| | ------------------
------------------
476| |
477| | /* Now we go over all objects in the graph to
478| | * - collect the attribute names and types
479| | * - collect node IDs
480| | * - set directedness
481| | * - do some checks which the following code relies on
482| | *
483| | * The 'id' fields of 'node' objects are converted into strings, so that they
484| | * can be inserted into a trie and re-encoded as consecutive integers starting
485| | * at 0. The GML spec allows isolated nodes with no 'id' field. These get a
486| | * generated string id of the form "n123" consisting of "n" and their count
487| | * (i.e. ordinal position) within the GML file.
488| | *
489| | * We use an attribute type value of IGRAPH_ATTRIBUTE_UNSPECIFIED to mark attribute
490| | * records which correspond to composite GML values and must therefore be removed
491| | * before creating the graph.
492| | */
493| 3.34k| node_no = 0;
494| 385k| for (i = 0; i < igraph_gml_tree_length(gtree); i++) {
------------------
| Branch (494:17): [True: 382k, False: 3.34k]
------------------
495| 382k| const char *name = igraph_gml_tree_name(gtree, i);
496| 382k| if (!strcmp(name, "node")) {
------------------
| Branch (496:13): [True: 33.4k, False: 349k]
------------------
497| 33.4k| igraph_gml_tree_t *node;
498| 33.4k| igraph_bool_t hasid;
499| 33.4k| node_no++;
500| 33.4k| no_of_nodes++;
501| 33.4k| if (igraph_gml_tree_type(gtree, i) != IGRAPH_I_GML_TREE_TREE) {
------------------
| Branch (501:17): [True: 0, False: 33.4k]
------------------
502| 0| IGRAPH_ERRORF("'node' is not a list in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
503| 0| igraph_gml_tree_line(gtree, i));
504| 0| }
505| 33.4k| node = igraph_gml_tree_get_tree(gtree, i);
506| 33.4k| hasid = false;
507| 84.9k| for (igraph_int_t j = 0; j < igraph_gml_tree_length(node); j++) {
------------------
| Branch (507:38): [True: 51.5k, False: 33.4k]
------------------
508| 51.5k| const char *name = igraph_gml_tree_name(node, j);
509| 51.5k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, j);
510| 51.5k| IGRAPH_CHECK(create_or_update_attribute(name, type, &vattrnames, &vattrs));
------------------
| | 656| 51.5k| do { \
| | 657| 51.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.5k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 51.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.5k]
| | ------------------
------------------
511| | /* check id */
512| 51.5k| if (!strcmp(name, "id")) {
------------------
| Branch (512:21): [True: 33.4k, False: 18.0k]
------------------
513| 33.4k| igraph_int_t id, trie_id;
514| 33.4k| igraph_int_t trie_size = igraph_trie_size(&trie);
515| 33.4k| if (hasid) {
------------------
| Branch (515:25): [True: 0, False: 33.4k]
------------------
516| | /* A 'node' must not have more than one 'id' field.
517| | * This error cannot be relaxed into a warning because all ids we find are
518| | * added to the trie, and eventually converted to igraph vertex ids. */
519| 0| IGRAPH_ERRORF("Node has multiple 'id' fields in GML file, line %" IGRAPH_PRId ".",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
520| 0| IGRAPH_PARSEERROR,
521| 0| igraph_gml_tree_line(node, j));
522| 0| }
523| 33.4k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (523:25): [True: 0, False: 33.4k]
------------------
524| 0| IGRAPH_ERRORF("Non-integer node id in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
525| 0| igraph_gml_tree_line(node, j));
526| 0| }
527| 33.4k| id = igraph_gml_tree_get_integer(node, j);
528| 33.4k| IGRAPH_CHECK(igraph_trie_get(&trie, strid(id, ""), &trie_id));
------------------
| | 656| 33.4k| do { \
| | 657| 33.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 33.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 33.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 33.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 33.4k]
| | ------------------
------------------
529| 33.4k| if (trie_id != trie_size) {
------------------
| Branch (529:25): [True: 0, False: 33.4k]
------------------
530| | /* This id has already been seen in a previous node. */
531| 0| IGRAPH_ERRORF("Duplicate node id in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
532| 0| igraph_gml_tree_line(node, j));
533| 0| }
534| 33.4k| hasid = true;
535| 33.4k| }
536| 51.5k| }
537| 33.4k| if (!hasid) {
------------------
| Branch (537:17): [True: 0, False: 33.4k]
------------------
538| | /* Isolated nodes are allowed not to have an id.
539| | * We generate an "n"-prefixed string id to be used in the trie. */
540| 0| igraph_int_t trie_id;
541| 0| IGRAPH_CHECK(igraph_trie_get(&trie, strid(node_no, "n"), &trie_id));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
542| 0| }
543| 349k| } else if (!strcmp(name, "edge")) {
------------------
| Branch (543:20): [True: 344k, False: 4.10k]
------------------
544| 344k| igraph_gml_tree_t *edge;
545| 344k| igraph_bool_t has_source = false, has_target = false;
546| 344k| no_of_edges++;
547| 344k| if (igraph_gml_tree_type(gtree, i) != IGRAPH_I_GML_TREE_TREE) {
------------------
| Branch (547:17): [True: 0, False: 344k]
------------------
548| 0| IGRAPH_ERRORF("'edge' is not a list in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
549| 0| igraph_gml_tree_line(gtree, i));
550| 0| }
551| 344k| edge = igraph_gml_tree_get_tree(gtree, i);
552| 1.39M| for (igraph_int_t j = 0; j < igraph_gml_tree_length(edge); j++) {
------------------
| Branch (552:38): [True: 1.05M, False: 344k]
------------------
553| 1.05M| const char *name = igraph_gml_tree_name(edge, j);
554| 1.05M| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(edge, j);
555| 1.05M| if (!strcmp(name, "source")) {
------------------
| Branch (555:21): [True: 344k, False: 707k]
------------------
556| 344k| if (has_source) {
------------------
| Branch (556:25): [True: 0, False: 344k]
------------------
557| | /* An edge must not have more than one 'source' field.
558| | * This could be relaxed to a warning, but we keep it as an error
559| | * for consistency with the handling of duplicate node 'id' field,
560| | * and because it indicates a serious corruption in the GML file. */
561| 0| IGRAPH_ERRORF("Duplicate 'source' in an edge in GML file, line %" IGRAPH_PRId ".",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
562| 0| IGRAPH_PARSEERROR,
563| 0| igraph_gml_tree_line(edge, j));
564| 0| }
565| 344k| has_source = true;
566| 344k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (566:25): [True: 0, False: 344k]
------------------
567| 0| IGRAPH_ERRORF("Non-integer 'source' for an edge in GML file, line %" IGRAPH_PRId ".",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
568| 0| IGRAPH_PARSEERROR,
569| 0| igraph_gml_tree_line(edge, j));
570| 0| }
571| 707k| } else if (!strcmp(name, "target")) {
------------------
| Branch (571:28): [True: 344k, False: 362k]
------------------
572| 344k| if (has_target) {
------------------
| Branch (572:25): [True: 0, False: 344k]
------------------
573| | /* An edge must not have more than one 'target' field. */
574| 0| IGRAPH_ERRORF("Duplicate 'target' in an edge in GML file, line %" IGRAPH_PRId ".",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
575| 0| IGRAPH_PARSEERROR,
576| 0| igraph_gml_tree_line(edge, j));
577| 0| }
578| 344k| has_target = true;
579| 344k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (579:25): [True: 0, False: 344k]
------------------
580| 0| IGRAPH_ERRORF("Non-integer 'target' for an edge in GML file, line %" IGRAPH_PRId ".",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
581| 0| IGRAPH_PARSEERROR,
582| 0| igraph_gml_tree_line(edge, j));
583| 0| }
584| 362k| } else {
585| 362k| IGRAPH_CHECK(create_or_update_attribute(name, type, &eattrnames, &eattrs));
------------------
| | 656| 362k| do { \
| | 657| 362k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 362k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 362k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 362k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 362k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 362k]
| | ------------------
------------------
586| 362k| }
587| 1.05M| } /* for */
588| 344k| if (!has_source) {
------------------
| Branch (588:17): [True: 0, False: 344k]
------------------
589| 0| IGRAPH_ERRORF("No 'source' for edge in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
590| 0| igraph_gml_tree_line(gtree, i));
591| 0| }
592| 344k| if (!has_target) {
------------------
| Branch (592:17): [True: 0, False: 344k]
------------------
593| 0| IGRAPH_ERRORF("No 'target' for edge in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
594| 0| igraph_gml_tree_line(gtree, i));
595| 0| }
596| 344k| } else if (! strcmp(name, "directed")) {
------------------
| Branch (596:20): [True: 3.34k, False: 769]
------------------
597| | /* Set directedness of graph. */
598| 3.34k| if (has_directed) {
------------------
| Branch (598:17): [True: 0, False: 3.34k]
------------------
599| | /* Be tolerant of duplicate entries, but do show a warning. */
600| 0| IGRAPH_WARNINGF("Duplicate 'directed' field in 'graph', line %" IGRAPH_PRId ". "
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
601| 0| "Ignoring previous 'directed' fields.",
602| 0| igraph_gml_tree_line(gtree, i));
603| 0| }
604| 3.34k| if (igraph_gml_tree_type(gtree, i) == IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (604:17): [True: 3.34k, False: 0]
------------------
605| 3.34k| igraph_int_t dir = igraph_gml_tree_get_integer(gtree, i);
606| 3.34k| if (dir != 0 && dir != 1) {
------------------
| Branch (606:21): [True: 137, False: 3.20k]
| Branch (606:33): [True: 0, False: 137]
------------------
607| 0| IGRAPH_WARNINGF(
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
608| 0| "Invalid value %" IGRAPH_PRId " for 'directed' attribute on line %" IGRAPH_PRId ", should be 0 or 1.",
609| 0| dir, igraph_gml_tree_line(gtree, i));
610| 0| }
611| 3.34k| if (dir) {
------------------
| Branch (611:21): [True: 137, False: 3.20k]
------------------
612| 137| directed = IGRAPH_DIRECTED;
613| 137| }
614| 3.34k| has_directed = true;
615| 3.34k| } else {
616| 0| IGRAPH_WARNINGF("Invalid type for 'directed' attribute on line %" IGRAPH_PRId ", assuming undirected.",
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
617| 0| igraph_gml_tree_line(gtree, i));
618| 0| }
619| 3.34k| } else {
620| | /* Add the rest of items as graph attributes. */
621| 769| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(gtree, i);
622| 769| IGRAPH_CHECK(create_or_update_attribute(name, type, &gattrnames, &gattrs));
------------------
| | 656| 769| do { \
| | 657| 769| igraph_error_t igraph_i_ret = (expr); \
| | 658| 769| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 769| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 769]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 769| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 769]
| | ------------------
------------------
623| 769| }
624| 382k| }
625| |
626| | /* At this point, all nodes must have an id (from the file or generated) stored
627| | * in the trie. Any condition that violates this should have been caught during
628| | * the preceding checks. */
629| 3.34k| IGRAPH_ASSERT(igraph_trie_size(&trie) == no_of_nodes);
------------------
| | 924| 3.34k| do { \
| | 925| 3.34k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.34k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.34k]
| | ------------------
------------------
630| |
631| | /* Now we allocate the vectors and strvectors for the attributes */
632| 3.34k| IGRAPH_CHECK(allocate_attributes(&vattrs, no_of_nodes, "vertex"));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
633| 3.34k| IGRAPH_CHECK(allocate_attributes(&eattrs, no_of_edges, "edge"));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
634| 3.34k| IGRAPH_CHECK(allocate_attributes(&gattrs, 1, "graph"));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
635| |
636| | /* Add edges, edge attributes and vertex attributes */
637| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, no_of_edges * 2);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
638| 3.34k| node_no = 0;
639| 385k| for (i = 0; i < igraph_gml_tree_length(gtree); i++) {
------------------
| Branch (639:17): [True: 382k, False: 3.34k]
------------------
640| 382k| const char *name;
641| 382k| name = igraph_gml_tree_name(gtree, i);
642| 382k| if (!strcmp(name, "node")) {
------------------
| Branch (642:13): [True: 33.4k, False: 349k]
------------------
643| 33.4k| igraph_gml_tree_t *node = igraph_gml_tree_get_tree(gtree, i);
644| 33.4k| igraph_int_t iidx = igraph_gml_tree_find(node, "id", 0);
645| 33.4k| igraph_int_t trie_id;
646| 33.4k| const char *sid;
647| 33.4k| node_no++;
648| 33.4k| if (iidx < 0) {
------------------
| Branch (648:17): [True: 0, False: 33.4k]
------------------
649| | /* Isolated node with no id field, use n-prefixed generated id */
650| 0| sid = strid(node_no, "n");
651| 33.4k| } else {
652| 33.4k| sid = strid(igraph_gml_tree_get_integer(node, iidx), "");
653| 33.4k| }
654| 33.4k| IGRAPH_CHECK(igraph_trie_get(&trie, sid, &trie_id));
------------------
| | 656| 33.4k| do { \
| | 657| 33.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 33.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 33.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33.4k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 33.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 33.4k]
| | ------------------
------------------
655| 84.9k| for (igraph_int_t j = 0; j < igraph_gml_tree_length(node); j++) {
------------------
| Branch (655:38): [True: 51.5k, False: 33.4k]
------------------
656| 51.5k| const char *aname = igraph_gml_tree_name(node, j);
657| 51.5k| igraph_attribute_record_t *atrec;
658| 51.5k| igraph_attribute_type_t type;
659| 51.5k| igraph_int_t ai;
660| 51.5k| IGRAPH_CHECK(igraph_trie_get(&vattrnames, aname, &ai));
------------------
| | 656| 51.5k| do { \
| | 657| 51.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.5k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 51.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.5k]
| | ------------------
------------------
661| 51.5k| atrec = igraph_attribute_record_list_get_ptr(&vattrs, ai);
662| 51.5k| type = atrec->type;
663| 51.5k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (663:21): [True: 39.9k, False: 11.5k]
------------------
664| 39.9k| VECTOR(*atrec->value.as_vector)[trie_id] = igraph_i_gml_toreal(node, j);
------------------
| | 60| 39.9k|#define VECTOR(v) ((v).stor_begin)
------------------
665| 39.9k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (665:28): [True: 11.5k, False: 0]
------------------
666| 11.5k| igraph_strvector_t *v = atrec->value.as_strvector;
667| 11.5k| const char *value = igraph_i_gml_tostring(node, j);
668| 11.5k| if (needs_coding(value)) {
------------------
| Branch (668:25): [True: 5.19k, False: 6.36k]
------------------
669| 5.19k| char *value_decoded;
670| 5.19k| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 656| 5.19k| do { \
| | 657| 5.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.19k]
| | ------------------
------------------
671| 5.19k| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 5.19k| do { \
| | 604| 5.19k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.19k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.19k| * incorrect destructor function with the pointer */ \
| | 607| 5.19k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.19k]
| | ------------------
| | 608| 5.19k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.19k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.19k]
| | ------------------
------------------
672| 5.19k| IGRAPH_CHECK(igraph_strvector_set(v, trie_id, value_decoded));
------------------
| | 656| 5.19k| do { \
| | 657| 5.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.19k]
| | ------------------
------------------
673| 5.19k| IGRAPH_FREE(value_decoded);
------------------
| | 36| 5.19k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
674| 5.19k| IGRAPH_FINALLY_CLEAN(1);
675| 6.36k| } else {
676| 6.36k| IGRAPH_CHECK(igraph_strvector_set(v, trie_id, value));
------------------
| | 656| 6.36k| do { \
| | 657| 6.36k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.36k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.36k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.36k]
| | ------------------
------------------
677| 6.36k| }
678| 11.5k| } else {
679| | /* Ignored composite attribute */
680| 0| }
681| 51.5k| }
682| 349k| } else if (!strcmp(name, "edge")) {
------------------
| Branch (682:20): [True: 344k, False: 4.10k]
------------------
683| 344k| igraph_gml_tree_t *edge;
684| 344k| igraph_int_t from, to, fromidx = 0, toidx = 0;
685| 344k| edge = igraph_gml_tree_get_tree(gtree, i);
686| 1.39M| for (igraph_int_t j = 0; j < igraph_gml_tree_length(edge); j++) {
------------------
| Branch (686:38): [True: 1.05M, False: 344k]
------------------
687| 1.05M| const char *aname = igraph_gml_tree_name(edge, j);
688| 1.05M| if (!strcmp(aname, "source")) {
------------------
| Branch (688:21): [True: 344k, False: 707k]
------------------
689| 344k| fromidx = igraph_gml_tree_find(edge, "source", 0);
690| 707k| } else if (!strcmp(aname, "target")) {
------------------
| Branch (690:28): [True: 344k, False: 362k]
------------------
691| 344k| toidx = igraph_gml_tree_find(edge, "target", 0);
692| 362k| } else {
693| 362k| igraph_int_t edgeid = edgeptr / 2;
694| 362k| igraph_int_t ai;
695| 362k| igraph_attribute_record_t *atrec;
696| 362k| igraph_attribute_type_t type;
697| 362k| IGRAPH_CHECK(igraph_trie_get(&eattrnames, aname, &ai));
------------------
| | 656| 362k| do { \
| | 657| 362k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 362k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 362k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 362k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 362k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 362k]
| | ------------------
------------------
698| 362k| atrec = igraph_attribute_record_list_get_ptr(&eattrs, ai);
699| 362k| type = atrec->type;
700| 362k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (700:25): [True: 7.12k, False: 355k]
------------------
701| 7.12k| VECTOR(*atrec->value.as_vector)[edgeid] = igraph_i_gml_toreal(edge, j);
------------------
| | 60| 7.12k|#define VECTOR(v) ((v).stor_begin)
------------------
702| 355k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (702:32): [True: 355k, False: 0]
------------------
703| 355k| igraph_strvector_t *v = atrec->value.as_strvector;
704| 355k| const char *value = igraph_i_gml_tostring(edge, j);
705| 355k| if (needs_coding(value)) {
------------------
| Branch (705:29): [True: 2.29k, False: 352k]
------------------
706| 2.29k| char *value_decoded;
707| 2.29k| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 656| 2.29k| do { \
| | 657| 2.29k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.29k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.29k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.29k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.29k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.29k]
| | ------------------
------------------
708| 2.29k| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 2.29k| do { \
| | 604| 2.29k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.29k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.29k| * incorrect destructor function with the pointer */ \
| | 607| 2.29k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.29k]
| | ------------------
| | 608| 2.29k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.29k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.29k]
| | ------------------
------------------
709| 2.29k| IGRAPH_CHECK(igraph_strvector_set(v, edgeid, value_decoded));
------------------
| | 656| 2.29k| do { \
| | 657| 2.29k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.29k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.29k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.29k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.29k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.29k]
| | ------------------
------------------
710| 2.29k| IGRAPH_FREE(value_decoded);
------------------
| | 36| 2.29k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
711| 2.29k| IGRAPH_FINALLY_CLEAN(1);
712| 352k| } else {
713| 352k| IGRAPH_CHECK(igraph_strvector_set(v, edgeid, value));
------------------
| | 656| 352k| do { \
| | 657| 352k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 352k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 352k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 352k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 352k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 352k]
| | ------------------
------------------
714| 352k| }
715| 355k| } else {
716| | /* Ignored composite attribute */
717| 0| }
718| 362k| }
719| 1.05M| }
720| 344k| from = igraph_gml_tree_get_integer(edge, fromidx);
721| 344k| to = igraph_gml_tree_get_integer(edge, toidx);
722| 344k| IGRAPH_CHECK(igraph_trie_check(&trie, strid(from, ""), &from));
------------------
| | 656| 344k| do { \
| | 657| 344k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344k]
| | ------------------
------------------
723| 344k| if (from < 0) {
------------------
| Branch (723:17): [True: 0, False: 344k]
------------------
724| 0| IGRAPH_ERRORF("Unknown source node id found in an edge in GML file, line %" IGRAPH_PRId ".",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
725| 0| IGRAPH_PARSEERROR, igraph_gml_tree_line(edge, fromidx));
726| 0| }
727| 344k| IGRAPH_CHECK(igraph_trie_check(&trie, strid(to, ""), &to));
------------------
| | 656| 344k| do { \
| | 657| 344k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344k]
| | ------------------
------------------
728| 344k| if (to < 0) {
------------------
| Branch (728:17): [True: 0, False: 344k]
------------------
729| 0| IGRAPH_ERRORF("Unknown target node id found in an edge in GML file, line %" IGRAPH_PRId ".",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
730| 0| IGRAPH_PARSEERROR, igraph_gml_tree_line(edge, toidx));
731| 0| }
732| 344k| VECTOR(edges)[edgeptr++] = from;
------------------
| | 60| 344k|#define VECTOR(v) ((v).stor_begin)
------------------
733| 344k| VECTOR(edges)[edgeptr++] = to;
------------------
| | 60| 344k|#define VECTOR(v) ((v).stor_begin)
------------------
734| 344k| } else if (! strcmp(name, "directed")) {
------------------
| Branch (734:20): [True: 3.34k, False: 769]
------------------
735| | /* Nothing to do for 'directed' field, already handled earlier. */
736| 3.34k| } else {
737| | /* Set the rest as graph attributes */
738| 769| igraph_int_t ai;
739| 769| igraph_attribute_record_t *atrec;
740| 769| igraph_attribute_type_t type;
741| 769| IGRAPH_CHECK(igraph_trie_get(&gattrnames, name, &ai));
------------------
| | 656| 769| do { \
| | 657| 769| igraph_error_t igraph_i_ret = (expr); \
| | 658| 769| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 769| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 769]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 769| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 769]
| | ------------------
------------------
742| 769| atrec = igraph_attribute_record_list_get_ptr(&gattrs, ai);
743| 769| type = atrec->type;
744| 769| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (744:17): [True: 163, False: 606]
------------------
745| 163| VECTOR(*atrec->value.as_vector)[0] = igraph_i_gml_toreal(gtree, i);
------------------
| | 60| 163|#define VECTOR(v) ((v).stor_begin)
------------------
746| 606| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (746:24): [True: 606, False: 0]
------------------
747| 606| igraph_strvector_t *v = atrec->value.as_strvector;
748| 606| const char *value = igraph_i_gml_tostring(gtree, i);
749| 606| if (needs_coding(value)) {
------------------
| Branch (749:21): [True: 76, False: 530]
------------------
750| 76| char *value_decoded;
751| 76| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 656| 76| do { \
| | 657| 76| igraph_error_t igraph_i_ret = (expr); \
| | 658| 76| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 76| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 76]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 76| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 76]
| | ------------------
------------------
752| 76| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 76| do { \
| | 604| 76| /* the following branch makes the compiler check the compatibility of \
| | 605| 76| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 76| * incorrect destructor function with the pointer */ \
| | 607| 76| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 76]
| | ------------------
| | 608| 76| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 76| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 76]
| | ------------------
------------------
753| 76| IGRAPH_CHECK(igraph_strvector_set(v, 0, value_decoded));
------------------
| | 656| 76| do { \
| | 657| 76| igraph_error_t igraph_i_ret = (expr); \
| | 658| 76| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 76| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 76]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 76| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 76]
| | ------------------
------------------
754| 76| IGRAPH_FREE(value_decoded);
------------------
| | 36| 76|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
755| 76| IGRAPH_FINALLY_CLEAN(1);
756| 530| } else {
757| 530| IGRAPH_CHECK(igraph_strvector_set(v, 0, value));
------------------
| | 656| 530| do { \
| | 657| 530| igraph_error_t igraph_i_ret = (expr); \
| | 658| 530| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 530| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 530]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 530| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 530]
| | ------------------
------------------
758| 530| }
759| 606| } else {
760| | /* Ignored composite attribute */
761| 0| }
762| 769| }
763| 382k| }
764| |
765| | /* Remove composite attributes that we cannot represent in igraph */
766| 3.34k| IGRAPH_CHECK(prune_unknown_attributes(&vattrs));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
767| 3.34k| IGRAPH_CHECK(prune_unknown_attributes(&eattrs));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
768| 3.34k| IGRAPH_CHECK(prune_unknown_attributes(&gattrs));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
769| |
770| 3.34k| igraph_trie_destroy(&trie);
771| 3.34k| igraph_trie_destroy(&gattrnames);
772| 3.34k| igraph_trie_destroy(&vattrnames);
773| 3.34k| igraph_trie_destroy(&eattrnames);
774| 3.34k| IGRAPH_FINALLY_CLEAN(4);
775| |
776| 3.34k| IGRAPH_CHECK(igraph_empty_attrs(graph, 0, directed, &gattrs));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
777| 3.34k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
778| 3.34k| IGRAPH_CHECK(igraph_add_vertices(graph, no_of_nodes, &vattrs));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
779| 3.34k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, &eattrs));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
780| 3.34k| IGRAPH_FINALLY_CLEAN(1); /* do not destroy 'graph', just pop it from the stack */
781| |
782| 3.34k| igraph_vector_int_destroy(&edges);
783| 3.34k| igraph_attribute_record_list_destroy(&eattrs);
784| 3.34k| igraph_attribute_record_list_destroy(&vattrs);
785| 3.34k| igraph_attribute_record_list_destroy(&gattrs);
786| 3.34k| igraph_i_gml_parsedata_destroy(&context);
787| 3.34k| IGRAPH_FINALLY_CLEAN(5);
788| |
789| 3.34k| return IGRAPH_SUCCESS;
790| 3.34k|}
igraph_write_graph_gml:
932| 3.34k| const igraph_vector_t *id, const char *creator) {
933| 3.34k| igraph_strvector_t gnames, vnames, enames; /* attribute names */
934| 3.34k| igraph_vector_int_t gtypes, vtypes, etypes; /* attribute types */
935| 3.34k| igraph_int_t gattr_no, vattr_no, eattr_no; /* attribute counts */
936| 3.34k| igraph_vector_t numv;
937| 3.34k| igraph_strvector_t strv;
938| 3.34k| igraph_vector_bool_t boolv;
939| 3.34k| igraph_int_t i;
940| 3.34k| igraph_int_t no_of_nodes = igraph_vcount(graph);
941| 3.34k| igraph_int_t no_of_edges = igraph_ecount(graph);
942| |
943| | /* Each element is a bit field used to prevent showing more
944| | * than one warning for each vertex or edge attribute. */
945| 3.34k| igraph_vector_int_t warning_shown;
946| |
947| 3.34k| igraph_vector_t v_myid;
948| 3.34k| const igraph_vector_t *myid = id;
949| |
950| | /* Creator line */
951| 3.34k| if (creator == NULL) {
------------------
| Branch (951:9): [True: 0, False: 3.34k]
------------------
952| 0| time_t curtime = time(0);
953| 0| char *timestr = ctime(&curtime);
954| 0| timestr[strlen(timestr) - 1] = '\0'; /* nicely remove \n */
955| |
956| 0| CHECK(fprintf(outstream,
------------------
| | 848| 0|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 0]
| | | Branch (848:116): [Folded, False: 0]
| | ------------------
------------------
957| 0| "Creator \"igraph version %s %s\"\n",
958| 0| IGRAPH_VERSION, timestr));
959| 3.34k| } else if (creator[0] == '\0') {
------------------
| Branch (959:16): [True: 0, False: 3.34k]
------------------
960| | /* creator == "", omit Creator line */
961| 3.34k| } else {
962| 3.34k| if (needs_coding(creator)) {
------------------
| Branch (962:13): [True: 0, False: 3.34k]
------------------
963| 0| char *d;
964| 0| IGRAPH_CHECK(entity_encode(creator, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
965| 0| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 0| do { \
| | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 0| * incorrect destructor function with the pointer */ \
| | 607| 0| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 0]
| | ------------------
| | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 0| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 0]
| | ------------------
------------------
966| 0| CHECK(fprintf(outstream,
------------------
| | 848| 0|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 0]
| | | Branch (848:116): [Folded, False: 0]
| | ------------------
------------------
967| 0| "Creator \"%s\"\n",
968| 0| creator));
969| 0| IGRAPH_FREE(d);
------------------
| | 36| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
970| 0| IGRAPH_FINALLY_CLEAN(1);
971| 3.34k| } else {
972| 3.34k| CHECK(fprintf(outstream,
------------------
| | 848| 3.34k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 3.34k]
| | | Branch (848:116): [Folded, False: 3.34k]
| | ------------------
------------------
973| 3.34k| "Creator \"%s\"\n",
974| 3.34k| creator));
975| 3.34k| }
976| 3.34k| }
977| |
978| | /* Version line */
979| 3.34k| CHECK(fprintf(outstream, "Version 1\n"));
------------------
| | 848| 3.34k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 3.34k]
| | | Branch (848:116): [Folded, False: 3.34k]
| | ------------------
------------------
980| |
981| | /* The graph */
982| 3.34k| CHECK(fprintf(outstream, "graph\n[\n"));
------------------
| | 848| 3.34k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 3.34k]
| | | Branch (848:116): [Folded, False: 3.34k]
| | ------------------
------------------
983| |
984| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
985| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
986| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
987| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
988| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
989| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
990| 3.34k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
991| 3.34k| &gnames, >ypes,
992| 3.34k| &vnames, &vtypes,
993| 3.34k| &enames, &etypes));
994| 3.34k| gattr_no = igraph_vector_int_size(>ypes);
995| 3.34k| vattr_no = igraph_vector_int_size(&vtypes);
996| 3.34k| eattr_no = igraph_vector_int_size(&etypes);
997| |
998| 3.34k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.34k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 105| 3.34k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.34k]
| | ------------------
------------------
999| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
1000| 3.34k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);
------------------
| | 109| 3.34k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 110| 3.34k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.34k]
| | ------------------
------------------
1001| |
1002| | /* Check whether there is an 'id' node attribute if the supplied is 0 */
1003| 3.34k| if (!id) {
------------------
| Branch (1003:9): [True: 3.34k, False: 0]
------------------
1004| 3.34k| igraph_bool_t found = false;
1005| 8.39k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1005:21): [True: 5.10k, False: 3.28k]
------------------
1006| 5.10k| const char *n = igraph_strvector_get(&vnames, i);
1007| 5.10k| if (!strcmp(n, "id") && VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 3.32k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1007:17): [True: 3.32k, False: 1.78k]
| Branch (1007:37): [True: 51, False: 3.27k]
------------------
1008| 51| found = true; break;
1009| 51| }
1010| 5.10k| }
1011| 3.34k| if (found) {
------------------
| Branch (1011:13): [True: 51, False: 3.28k]
------------------
1012| 51| IGRAPH_VECTOR_INIT_FINALLY(&v_myid, no_of_nodes);
------------------
| | 104| 51| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 51| do { \
| | | | 657| 51| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 51| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 51| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 51]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 51| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 51]
| | | | ------------------
| | ------------------
| | 105| 51| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 51| do { \
| | | | 604| 51| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 51| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 51| * incorrect destructor function with the pointer */ \
| | | | 607| 51| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 51]
| | | | ------------------
| | | | 608| 51| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 51| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 51]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 51]
| | ------------------
------------------
1013| 51| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, "id",
------------------
| | 656| 51| do { \
| | 657| 51| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 51| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51]
| | ------------------
------------------
1014| 51| igraph_vss_all(),
1015| 51| &v_myid));
1016| 51| myid = &v_myid;
1017| 51| }
1018| 3.34k| }
1019| |
1020| | /* Scan id vector for invalid values. If any are found, all ids are ignored.
1021| | * Invalid values may occur as a result of reading a GML file in which some
1022| | * nodes did not have an id, or by adding new vertices to a graph with an "id"
1023| | * attribute. In this case, the "id" attribute will contain NaN values.
1024| | */
1025| 3.34k| if (myid) {
------------------
| Branch (1025:9): [True: 51, False: 3.28k]
------------------
1026| 51| if (igraph_vector_size(myid) != no_of_nodes) {
------------------
| Branch (1026:13): [True: 0, False: 51]
------------------
1027| 0| IGRAPH_ERROR("Size of id vector must match vertex count.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1028| 0| }
1029| 2.02k| for (i = 0; i < no_of_nodes; ++i) {
------------------
| Branch (1029:21): [True: 1.98k, False: 48]
------------------
1030| 1.98k| igraph_real_t val = VECTOR(*myid)[i];
------------------
| | 60| 1.98k|#define VECTOR(v) ((v).stor_begin)
------------------
1031| 1.98k| igraph_real_t trunc_val = trunc(val);
1032| 1.98k| if (! (val == trunc_val && igraph_i_is_real_representable_as_integer(trunc_val))) {
------------------
| Branch (1032:20): [True: 1.97k, False: 2]
| Branch (1032:40): [True: 1.97k, False: 1]
------------------
1033| 3| IGRAPH_WARNINGF("%g is not a valid integer id for GML files, ignoring all supplied ids.", val);
------------------
| | 777| 3| do { \
| | 778| 3| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3| __VA_ARGS__); \
| | 780| 3| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3]
| | ------------------
------------------
1034| 3| if (myid == &v_myid) {
------------------
| Branch (1034:21): [True: 3, False: 0]
------------------
1035| 3| igraph_vector_destroy(&v_myid);
1036| 3| IGRAPH_FINALLY_CLEAN(1);
1037| 3| }
1038| 3| myid = NULL;
1039| 3| break;
1040| 3| }
1041| 1.98k| }
1042| 51| }
1043| |
1044| 3.34k| if (myid) {
------------------
| Branch (1044:9): [True: 48, False: 3.29k]
------------------
1045| 48| igraph_bool_t duplicate_free;
1046| 48| IGRAPH_CHECK(igraph_i_vector_is_duplicate_free(myid, &duplicate_free));
------------------
| | 656| 48| do { \
| | 657| 48| igraph_error_t igraph_i_ret = (expr); \
| | 658| 48| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 48| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 48]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 48| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 48]
| | ------------------
------------------
1047| 48| if (! duplicate_free) {
------------------
| Branch (1047:13): [True: 37, False: 11]
------------------
1048| 37| IGRAPH_WARNING("Duplicate id values found, ignoring supplies ids.");
------------------
| | 797| 37| do { \
| | 798| 37| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 37| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 37]
| | ------------------
------------------
1049| 37| if (myid == &v_myid) {
------------------
| Branch (1049:17): [True: 37, False: 0]
------------------
1050| 37| igraph_vector_destroy(&v_myid);
1051| 37| IGRAPH_FINALLY_CLEAN(1);
1052| 37| }
1053| 37| myid = NULL;
1054| 37| }
1055| 48| }
1056| |
1057| | /* directedness */
1058| 3.34k| CHECK(fprintf(outstream, " directed %i\n", igraph_is_directed(graph) ? 1 : 0));
------------------
| | 848| 6.68k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:33): [True: 137, False: 3.20k]
| | | Branch (848:42): [True: 0, False: 3.34k]
| | | Branch (848:116): [Folded, False: 3.34k]
| | ------------------
------------------
1059| |
1060| | /* Graph attributes first */
1061| 4.18k| for (i = 0; i < gattr_no; i++) {
------------------
| Branch (1061:17): [True: 849, False: 3.34k]
------------------
1062| 849| const char *name;
1063| 849| char *newname;
1064| 849| name = igraph_strvector_get(&gnames, i);
1065| 849| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 656| 849| do { \
| | 657| 849| igraph_error_t igraph_i_ret = (expr); \
| | 658| 849| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 849| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 849]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 849| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 849]
| | ------------------
------------------
1066| 849| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 849| do { \
| | 604| 849| /* the following branch makes the compiler check the compatibility of \
| | 605| 849| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 849| * incorrect destructor function with the pointer */ \
| | 607| 849| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 849]
| | ------------------
| | 608| 849| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 849| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 849]
| | ------------------
------------------
1067| 849| if (!strcmp(newname, "directed")|| !strcmp(newname, "edge") || !strcmp(newname, "node")) {
------------------
| Branch (1067:13): [True: 4, False: 845]
| Branch (1067:44): [True: 3, False: 842]
| Branch (1067:72): [True: 6, False: 836]
------------------
1068| 13| IGRAPH_WARNINGF("The graph attribute '%s' was ignored while writing GML format.", name);
------------------
| | 777| 13| do { \
| | 778| 13| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 13| __VA_ARGS__); \
| | 780| 13| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 13]
| | ------------------
------------------
1069| 836| } else {
1070| 836| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 836|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1070:17): [True: 105, False: 731]
------------------
1071| 105| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 105| do { \
| | 657| 105| igraph_error_t igraph_i_ret = (expr); \
| | 658| 105| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 105| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 105]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 105| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 105]
| | ------------------
------------------
1072| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1073| 105| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1073:21): [True: 38, False: 67]
------------------
1074| 38| if (! isfinite(VECTOR(numv)[0])) {
------------------
| Branch (1074:25): [True: 0, False: 38]
------------------
1075| 0| IGRAPH_WARNINGF("Infinite value in numeric graph attribute '%s'. "
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
1076| 0| "Produced GML file will not be conformant.", name);
1077| 0| }
1078| 38| CHECK(fprintf(outstream, " %s ", newname));
------------------
| | 848| 38|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 38]
| | | Branch (848:116): [Folded, False: 38]
| | ------------------
------------------
1079| 38| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
------------------
| | 848| 38|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 38]
| | | Branch (848:116): [Folded, False: 38]
| | ------------------
------------------
1080| 38| CHECK(fputc('\n', outstream));
------------------
| | 848| 38|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 38]
| | | Branch (848:116): [Folded, False: 38]
| | ------------------
------------------
1081| 38| }
1082| 731| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 731|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1082:24): [True: 594, False: 137]
------------------
1083| 594| const char *s;
1084| 594| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 594| do { \
| | 657| 594| igraph_error_t igraph_i_ret = (expr); \
| | 658| 594| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 594| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 594]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 594| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 594]
| | ------------------
------------------
1085| 594| s = igraph_strvector_get(&strv, 0);
1086| 594| if (needs_coding(s)) {
------------------
| Branch (1086:21): [True: 76, False: 518]
------------------
1087| 76| char *d;
1088| 76| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 76| do { \
| | 657| 76| igraph_error_t igraph_i_ret = (expr); \
| | 658| 76| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 76| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 76]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 76| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 76]
| | ------------------
------------------
1089| 76| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 76| do { \
| | 604| 76| /* the following branch makes the compiler check the compatibility of \
| | 605| 76| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 76| * incorrect destructor function with the pointer */ \
| | 607| 76| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 76]
| | ------------------
| | 608| 76| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 76| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 76]
| | ------------------
------------------
1090| 76| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 76|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 76]
| | | Branch (848:116): [Folded, False: 76]
| | ------------------
------------------
1091| 76| IGRAPH_FREE(d);
------------------
| | 36| 76|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1092| 76| IGRAPH_FINALLY_CLEAN(1);
1093| 518| } else {
1094| 518| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 518|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 518]
| | | Branch (848:116): [Folded, False: 518]
| | ------------------
------------------
1095| 518| }
1096| 594| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 137|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1096:24): [True: 137, False: 0]
------------------
1097| 137| IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
------------------
| | 656| 137| do { \
| | 657| 137| igraph_error_t igraph_i_ret = (expr); \
| | 658| 137| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 137| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 137]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 137| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 137]
| | ------------------
------------------
1098| 137| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 274|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:33): [True: 0, False: 137]
| | | Branch (848:42): [True: 0, False: 137]
| | | Branch (848:116): [Folded, False: 137]
| | ------------------
------------------
1099| 137| IGRAPH_WARNING("A boolean graph attribute was converted to numeric.");
------------------
| | 797| 137| do { \
| | 798| 137| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 137| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 137]
| | ------------------
------------------
1100| 137| } else {
1101| 0| IGRAPH_WARNING("A non-numeric, non-string, non-boolean graph attribute ignored.");
------------------
| | 797| 0| do { \
| | 798| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 0| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 0]
| | ------------------
------------------
1102| 0| }
1103| 836| }
1104| 849| IGRAPH_FREE(newname);
------------------
| | 36| 849|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1105| 849| IGRAPH_FINALLY_CLEAN(1);
1106| 849| }
1107| |
1108| | /* Macros used to work with the bit fiels in 'warning_shown',
1109| | * and avoid showing warnings more than once for each attribute. */
1110| 3.34k|#define GETBIT(k, i) ((k) & (1 << i))
1111| 3.34k|#define SETBIT(k, i) ((k) |= (1 << i))
1112| 3.34k|#define WARN_ONCE(attrno, bit, warn) \
1113| 3.34k| do { \
1114| 3.34k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
1115| 3.34k| if (! GETBIT(*p, bit)) { \
1116| 3.34k| warn; \
1117| 3.34k| SETBIT(*p, bit); \
1118| 3.34k| } \
1119| 3.34k| } while (0)
1120| |
1121| |
1122| | /* Now come the vertices */
1123| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&warning_shown, vattr_no);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
1124| 36.8k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1124:17): [True: 33.4k, False: 3.34k]
------------------
1125| 33.4k| igraph_int_t j;
1126| 33.4k| CHECK(fprintf(outstream, " node\n [\n"));
------------------
| | 848| 33.4k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 33.4k]
| | | Branch (848:116): [Folded, False: 33.4k]
| | ------------------
------------------
1127| | /* id */
1128| 33.4k| CHECK(fprintf(outstream, " id %" IGRAPH_PRId "\n", myid ? (igraph_int_t)VECTOR(*myid)[i] : i));
------------------
| | 848| 66.9k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:33): [True: 8, False: 33.4k]
| | | Branch (848:42): [True: 0, False: 33.4k]
| | | Branch (848:116): [Folded, False: 33.4k]
| | ------------------
------------------
1129| | /* other attributes */
1130| 86.1k| for (j = 0; j < vattr_no; j++) {
------------------
| Branch (1130:21): [True: 52.6k, False: 33.4k]
------------------
1131| 52.6k| igraph_attribute_type_t type = (igraph_attribute_type_t) VECTOR(vtypes)[j];
------------------
| | 60| 52.6k|#define VECTOR(v) ((v).stor_begin)
------------------
1132| 52.6k| const char *name;
1133| 52.6k| char *newname;
1134| 52.6k| name = igraph_strvector_get(&vnames, j);
1135| 52.6k| if (!strcmp(name, "id")) {
------------------
| Branch (1135:17): [True: 33.2k, False: 19.3k]
------------------
1136| | /* No warning, the presence of this attribute is expected, and is handled specially. */
1137| 33.2k| continue;
1138| 33.2k| }
1139| 19.3k| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 656| 19.3k| do { \
| | 657| 19.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19.3k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.3k]
| | ------------------
------------------
1140| 19.3k| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 19.3k| do { \
| | 604| 19.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 19.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 19.3k| * incorrect destructor function with the pointer */ \
| | 607| 19.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 19.3k]
| | ------------------
| | 608| 19.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 19.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 19.3k]
| | ------------------
------------------
1141| 19.3k| if (!strcmp(newname, "id")) {
------------------
| Branch (1141:17): [True: 366, False: 18.9k]
------------------
1142| | /* In case an attribute name would conflict with 'id' only after encoding. */
1143| 366| WARN_ONCE(j, 0,
------------------
| | 1113| 366| do { \
| | 1114| 366| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 366|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 366| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 366|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 11, False: 355]
| | ------------------
| | 1116| 22| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 11]
| | ------------------
| | 1117| 11| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 11|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 11| } \
| | 1119| 366| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 366]
| | ------------------
------------------
1144| 366| IGRAPH_WARNINGF("The vertex attribute '%s' was ignored while writing GML format.", name));
1145| 18.9k| } else {
1146| 18.9k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (1146:21): [True: 2.99k, False: 15.9k]
------------------
1147| 2.99k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name,
------------------
| | 656| 2.99k| do { \
| | 657| 2.99k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.99k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.99k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.99k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.99k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.99k]
| | ------------------
------------------
1148| 2.99k| igraph_vss_1(i), &numv));
1149| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1150| 2.99k| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1150:25): [True: 2.02k, False: 967]
------------------
1151| 2.02k| if (! isfinite(VECTOR(numv)[0])) {
------------------
| Branch (1151:29): [True: 0, False: 2.02k]
------------------
1152| 0| WARN_ONCE(j, 3,
------------------
| | 1113| 0| do { \
| | 1114| 0| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 0| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 0|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 0, False: 0]
| | ------------------
| | 1116| 0| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 0]
| | ------------------
| | 1117| 0| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 0|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 0| } \
| | 1119| 0| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 0]
| | ------------------
------------------
1153| 0| IGRAPH_WARNINGF("Infinite value in numeric vertex attribute '%s'. "
1154| 0| "Produced GML file will not be conformant.", name));
1155| 0| }
1156| 2.02k| CHECK(fprintf(outstream, " %s ", newname));
------------------
| | 848| 2.02k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 2.02k]
| | | Branch (848:116): [Folded, False: 2.02k]
| | ------------------
------------------
1157| 2.02k| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
------------------
| | 848| 2.02k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 2.02k]
| | | Branch (848:116): [Folded, False: 2.02k]
| | ------------------
------------------
1158| 2.02k| CHECK(fputc('\n', outstream));
------------------
| | 848| 2.02k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 2.02k]
| | | Branch (848:116): [Folded, False: 2.02k]
| | ------------------
------------------
1159| 2.02k| }
1160| 15.9k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (1160:28): [True: 11.5k, False: 4.44k]
------------------
1161| 11.5k| const char *s;
1162| 11.5k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name,
------------------
| | 656| 11.5k| do { \
| | 657| 11.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.5k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 11.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.5k]
| | ------------------
------------------
1163| 11.5k| igraph_vss_1(i), &strv));
1164| 11.5k| s = igraph_strvector_get(&strv, 0);
1165| 11.5k| if (needs_coding(s)) {
------------------
| Branch (1165:25): [True: 5.19k, False: 6.36k]
------------------
1166| 5.19k| char *d;
1167| 5.19k| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 5.19k| do { \
| | 657| 5.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.19k]
| | ------------------
------------------
1168| 5.19k| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 5.19k| do { \
| | 604| 5.19k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.19k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.19k| * incorrect destructor function with the pointer */ \
| | 607| 5.19k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.19k]
| | ------------------
| | 608| 5.19k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.19k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.19k]
| | ------------------
------------------
1169| 5.19k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 5.19k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 5.19k]
| | | Branch (848:116): [Folded, False: 5.19k]
| | ------------------
------------------
1170| 5.19k| IGRAPH_FREE(d);
------------------
| | 36| 5.19k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1171| 5.19k| IGRAPH_FINALLY_CLEAN(1);
1172| 6.36k| } else {
1173| 6.36k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 6.36k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 6.36k]
| | | Branch (848:116): [Folded, False: 6.36k]
| | ------------------
------------------
1174| 6.36k| }
1175| 11.5k| } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (1175:28): [True: 4.44k, False: 0]
------------------
1176| 4.44k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name,
------------------
| | 656| 4.44k| do { \
| | 657| 4.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.44k]
| | ------------------
------------------
1177| 4.44k| igraph_vss_1(i), &boolv));
1178| 4.44k| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 8.89k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:33): [True: 16, False: 4.42k]
| | | Branch (848:42): [True: 0, False: 4.44k]
| | | Branch (848:116): [Folded, False: 4.44k]
| | ------------------
------------------
1179| 4.44k| WARN_ONCE(j, 1,
------------------
| | 1113| 4.44k| do { \
| | 1114| 4.44k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 4.44k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 4.44k| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 4.44k|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 470, False: 3.97k]
| | ------------------
| | 1116| 940| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 470]
| | ------------------
| | 1117| 470| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 470|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 470| } \
| | 1119| 4.44k| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 4.44k]
| | ------------------
------------------
1180| 4.44k| IGRAPH_WARNINGF("The boolean vertex attribute '%s' was converted to numeric.", name));
1181| 4.44k| } else {
1182| 0| WARN_ONCE(j, 2,
------------------
| | 1113| 0| do { \
| | 1114| 0| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 0| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 0|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 0, False: 0]
| | ------------------
| | 1116| 0| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 0]
| | ------------------
| | 1117| 0| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 0|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 0| } \
| | 1119| 0| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 0]
| | ------------------
------------------
1183| 0| IGRAPH_WARNINGF("The non-numeric, non-string, non-boolean vertex attribute '%s' was ignored.", name));
1184| 0| }
1185| 18.9k| }
1186| 19.3k| IGRAPH_FREE(newname);
------------------
| | 36| 19.3k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1187| 19.3k| IGRAPH_FINALLY_CLEAN(1);
1188| 19.3k| }
1189| 33.4k| CHECK(fprintf(outstream, " ]\n"));
------------------
| | 848| 33.4k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 33.4k]
| | | Branch (848:116): [Folded, False: 33.4k]
| | ------------------
------------------
1190| 33.4k| }
1191| |
1192| | /* The edges too */
1193| 3.34k| IGRAPH_CHECK(igraph_vector_int_resize(&warning_shown, eattr_no));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
1194| 3.34k| igraph_vector_int_null(&warning_shown);
1195| 348k| for (i = 0; i < no_of_edges; i++) {
------------------
| Branch (1195:17): [True: 344k, False: 3.34k]
------------------
1196| 344k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 344k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 344k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1197| 344k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 344k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 344k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1198| 344k| igraph_int_t j;
1199| 344k| CHECK(fprintf(outstream, " edge\n [\n"));
------------------
| | 848| 344k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 344k]
| | | Branch (848:116): [Folded, False: 344k]
| | ------------------
------------------
1200| | /* source and target */
1201| 344k| CHECK(fprintf(outstream, " source %" IGRAPH_PRId "\n",
------------------
| | 848| 689k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:33): [True: 69, False: 344k]
| | | Branch (848:42): [True: 0, False: 344k]
| | | Branch (848:116): [Folded, False: 344k]
| | ------------------
------------------
1202| 344k| myid ? (igraph_int_t)VECTOR(*myid)[from] : from));
1203| 344k| CHECK(fprintf(outstream, " target %" IGRAPH_PRId "\n",
------------------
| | 848| 689k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:33): [True: 69, False: 344k]
| | | Branch (848:42): [True: 0, False: 344k]
| | | Branch (848:116): [Folded, False: 344k]
| | ------------------
------------------
1204| 344k| myid ? (igraph_int_t)VECTOR(*myid)[to] : to));
1205| |
1206| | /* other attributes */
1207| 804k| for (j = 0; j < eattr_no; j++) {
------------------
| Branch (1207:21): [True: 460k, False: 344k]
------------------
1208| 460k| igraph_attribute_type_t type = (igraph_attribute_type_t) VECTOR(etypes)[j];
------------------
| | 60| 460k|#define VECTOR(v) ((v).stor_begin)
------------------
1209| 460k| const char *name;
1210| 460k| char *newname;
1211| 460k| name = igraph_strvector_get(&enames, j);
1212| 460k| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 656| 460k| do { \
| | 657| 460k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 460k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 460k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 460k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 460k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 460k]
| | ------------------
------------------
1213| 460k| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 460k| do { \
| | 604| 460k| /* the following branch makes the compiler check the compatibility of \
| | 605| 460k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 460k| * incorrect destructor function with the pointer */ \
| | 607| 460k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 460k]
| | ------------------
| | 608| 460k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 460k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 460k]
| | ------------------
------------------
1214| 460k| if (!strcmp(newname, "source") || !strcmp(newname, "target")) {
------------------
| Branch (1214:17): [True: 639, False: 459k]
| Branch (1214:47): [True: 347, False: 459k]
------------------
1215| 986| WARN_ONCE(j, 0,
------------------
| | 1113| 986| do { \
| | 1114| 986| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 986|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 986| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 986|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 24, False: 962]
| | ------------------
| | 1116| 48| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 24]
| | ------------------
| | 1117| 24| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 24|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 24| } \
| | 1119| 986| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 986]
| | ------------------
------------------
1216| 986| IGRAPH_WARNINGF("The edge attribute '%s' was ignored while writing GML format.", name));
1217| 459k| } else {
1218| 459k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (1218:21): [True: 97.9k, False: 361k]
------------------
1219| 97.9k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, name,
------------------
| | 656| 97.9k| do { \
| | 657| 97.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 97.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 97.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 97.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 97.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 97.9k]
| | ------------------
------------------
1220| 97.9k| igraph_ess_1(i), &numv));
1221| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1222| 97.9k| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1222:25): [True: 1.25k, False: 96.6k]
------------------
1223| 1.25k| if (! isfinite(VECTOR(numv)[0])) {
------------------
| Branch (1223:29): [True: 0, False: 1.25k]
------------------
1224| 0| WARN_ONCE(j, 3,
------------------
| | 1113| 0| do { \
| | 1114| 0| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 0| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 0|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 0, False: 0]
| | ------------------
| | 1116| 0| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 0]
| | ------------------
| | 1117| 0| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 0|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 0| } \
| | 1119| 0| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 0]
| | ------------------
------------------
1225| 0| IGRAPH_WARNINGF("Infinite value in numeric edge attribute '%s'. "
1226| 0| "Produced GML file will not be conformant.", name));
1227| 0| }
1228| 1.25k| CHECK(fprintf(outstream, " %s ", newname));
------------------
| | 848| 1.25k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 1.25k]
| | | Branch (848:116): [Folded, False: 1.25k]
| | ------------------
------------------
1229| 1.25k| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
------------------
| | 848| 1.25k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 1.25k]
| | | Branch (848:116): [Folded, False: 1.25k]
| | ------------------
------------------
1230| 1.25k| CHECK(fputc('\n', outstream));
------------------
| | 848| 1.25k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 1.25k]
| | | Branch (848:116): [Folded, False: 1.25k]
| | ------------------
------------------
1231| 1.25k| }
1232| 361k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (1232:28): [True: 354k, False: 6.54k]
------------------
1233| 354k| const char *s;
1234| 354k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, name,
------------------
| | 656| 354k| do { \
| | 657| 354k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 354k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 354k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 354k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 354k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 354k]
| | ------------------
------------------
1235| 354k| igraph_ess_1(i), &strv));
1236| 354k| s = igraph_strvector_get(&strv, 0);
1237| 354k| if (needs_coding(s)) {
------------------
| Branch (1237:25): [True: 2.29k, False: 352k]
------------------
1238| 2.29k| char *d;
1239| 2.29k| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 2.29k| do { \
| | 657| 2.29k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.29k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.29k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.29k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.29k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.29k]
| | ------------------
------------------
1240| 2.29k| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 2.29k| do { \
| | 604| 2.29k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.29k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.29k| * incorrect destructor function with the pointer */ \
| | 607| 2.29k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.29k]
| | ------------------
| | 608| 2.29k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.29k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.29k]
| | ------------------
------------------
1241| 2.29k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 2.29k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 2.29k]
| | | Branch (848:116): [Folded, False: 2.29k]
| | ------------------
------------------
1242| 2.29k| IGRAPH_FREE(d);
------------------
| | 36| 2.29k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1243| 2.29k| IGRAPH_FINALLY_CLEAN(1);
1244| 352k| } else {
1245| 352k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 352k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 352k]
| | | Branch (848:116): [Folded, False: 352k]
| | ------------------
------------------
1246| 352k| }
1247| 354k| } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (1247:28): [True: 6.54k, False: 0]
------------------
1248| 6.54k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph, name,
------------------
| | 656| 6.54k| do { \
| | 657| 6.54k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.54k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.54k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.54k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.54k]
| | ------------------
------------------
1249| 6.54k| igraph_ess_1(i), &boolv));
1250| 6.54k| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 13.0k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:33): [True: 0, False: 6.54k]
| | | Branch (848:42): [True: 0, False: 6.54k]
| | | Branch (848:116): [Folded, False: 6.54k]
| | ------------------
------------------
1251| 6.54k| WARN_ONCE(j, 1,
------------------
| | 1113| 6.54k| do { \
| | 1114| 6.54k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 6.54k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 6.54k| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 6.54k|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 446, False: 6.10k]
| | ------------------
| | 1116| 892| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 446]
| | ------------------
| | 1117| 446| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 446|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 446| } \
| | 1119| 6.54k| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 6.54k]
| | ------------------
------------------
1252| 6.54k| IGRAPH_WARNINGF("The boolean edge attribute '%s' was converted to numeric.", name));
1253| 6.54k| } else {
1254| 0| WARN_ONCE(j, 2,
------------------
| | 1113| 0| do { \
| | 1114| 0| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 0| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 0|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 0, False: 0]
| | ------------------
| | 1116| 0| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 0]
| | ------------------
| | 1117| 0| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 0|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 0| } \
| | 1119| 0| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 0]
| | ------------------
------------------
1255| 0| IGRAPH_WARNINGF("The non-numeric, non-string, non-boolean edge attribute '%s' was ignored.", name));
1256| 0| }
1257| 459k| }
1258| 460k| IGRAPH_FREE(newname);
------------------
| | 36| 460k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1259| 460k| IGRAPH_FINALLY_CLEAN(1);
1260| 460k| }
1261| 344k| CHECK(fprintf(outstream, " ]\n"));
------------------
| | 848| 344k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 344k]
| | | Branch (848:116): [Folded, False: 344k]
| | ------------------
------------------
1262| 344k| }
1263| |
1264| 3.34k| CHECK(fprintf(outstream, "]\n"));
------------------
| | 848| 3.34k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 3.34k]
| | | Branch (848:116): [Folded, False: 3.34k]
| | ------------------
------------------
1265| |
1266| 3.34k|#undef GETBIT
1267| 3.34k|#undef SETBIT
1268| 3.34k|#undef WARN_ONCE
1269| |
1270| 3.34k| if (&v_myid == myid) {
------------------
| Branch (1270:9): [True: 11, False: 3.32k]
------------------
1271| 11| igraph_vector_destroy(&v_myid);
1272| 11| IGRAPH_FINALLY_CLEAN(1);
1273| 11| }
1274| |
1275| 3.34k| igraph_vector_int_destroy(&warning_shown);
1276| 3.34k| igraph_vector_bool_destroy(&boolv);
1277| 3.34k| igraph_strvector_destroy(&strv);
1278| 3.34k| igraph_vector_destroy(&numv);
1279| 3.34k| igraph_vector_int_destroy(&etypes);
1280| 3.34k| igraph_vector_int_destroy(&vtypes);
1281| 3.34k| igraph_vector_int_destroy(>ypes);
1282| 3.34k| igraph_strvector_destroy(&enames);
1283| 3.34k| igraph_strvector_destroy(&vnames);
1284| 3.34k| igraph_strvector_destroy(&gnames);
1285| 3.34k| IGRAPH_FINALLY_CLEAN(10);
1286| |
1287| 3.34k| return IGRAPH_SUCCESS;
1288| 3.34k|}
gml.c:create_or_update_attribute:
274| 414k| igraph_attribute_record_list_t *attrs) {
275| |
276| 414k| igraph_int_t trieid, triesize = igraph_trie_size(attrnames);
277| 414k| igraph_attribute_type_t desired_type;
278| |
279| 414k| IGRAPH_CHECK(igraph_trie_get(attrnames, name, &trieid));
------------------
| | 656| 414k| do { \
| | 657| 414k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 414k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 414k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 414k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 414k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 414k]
| | ------------------
------------------
280| 414k| if (trieid == triesize) {
------------------
| Branch (280:9): [True: 6.90k, False: 407k]
------------------
281| | /* new attribute */
282| 6.90k| igraph_attribute_record_t atrec;
283| |
284| 6.90k| if (type == IGRAPH_I_GML_TREE_INTEGER || type == IGRAPH_I_GML_TREE_REAL) {
------------------
| Branch (284:13): [True: 3.81k, False: 3.08k]
| Branch (284:50): [True: 43, False: 3.03k]
------------------
285| 3.86k| desired_type = IGRAPH_ATTRIBUTE_NUMERIC;
286| 3.86k| } else if (type == IGRAPH_I_GML_TREE_STRING) {
------------------
| Branch (286:20): [True: 3.03k, False: 0]
------------------
287| 3.03k| desired_type = IGRAPH_ATTRIBUTE_STRING;
288| 3.03k| } else {
289| 0| desired_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
290| 0| }
291| |
292| 6.90k| IGRAPH_CHECK(igraph_attribute_record_init(&atrec, name, desired_type));
------------------
| | 656| 6.90k| do { \
| | 657| 6.90k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.90k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.90k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.90k]
| | ------------------
------------------
293| 6.90k| IGRAPH_FINALLY(igraph_attribute_record_destroy, &atrec);
------------------
| | 603| 6.90k| do { \
| | 604| 6.90k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.90k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.90k| * incorrect destructor function with the pointer */ \
| | 607| 6.90k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.90k]
| | ------------------
| | 608| 6.90k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.90k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.90k]
| | ------------------
------------------
294| 6.90k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(attrs, &atrec));
------------------
| | 656| 6.90k| do { \
| | 657| 6.90k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.90k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.90k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.90k]
| | ------------------
------------------
295| 6.90k| IGRAPH_FINALLY_CLEAN(1); /* ownership of 'atrec' taken by 'attrs' */
296| 407k| } else {
297| | /* already seen, should we update type? */
298| 407k| igraph_attribute_record_t *atrec = igraph_attribute_record_list_get_ptr(attrs, trieid);
299| 407k| igraph_attribute_type_t existing_type = atrec->type;
300| 407k| if (type == IGRAPH_I_GML_TREE_STRING) {
------------------
| Branch (300:13): [True: 363k, False: 44.0k]
------------------
301| 363k| if (existing_type != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (301:17): [True: 19, False: 363k]
------------------
302| 19| IGRAPH_CHECK(igraph_attribute_record_set_type(atrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 19| do { \
| | 657| 19| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19]
| | ------------------
------------------
303| 19| }
304| 363k| } else if (existing_type == IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (304:20): [True: 0, False: 44.0k]
------------------
305| 0| if (type == IGRAPH_I_GML_TREE_INTEGER || type == IGRAPH_I_GML_TREE_REAL) {
------------------
| Branch (305:17): [True: 0, False: 0]
| Branch (305:54): [True: 0, False: 0]
------------------
306| 0| IGRAPH_CHECK(igraph_attribute_record_set_type(atrec, IGRAPH_ATTRIBUTE_NUMERIC));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
307| 0| }
308| 0| }
309| 407k| }
310| |
311| 414k| return IGRAPH_SUCCESS;
312| 414k|}
gml.c:strid:
262| 756k|static const char *strid(igraph_int_t id, const char *prefix) {
263| 756k| static char name[100];
264| | snprintf(name, sizeof(name) / sizeof(char) - 1, "%s%" IGRAPH_PRId, prefix, id);
------------------
| | 63| 756k|# define IGRAPH_PRId PRId64
------------------
265| 756k| return name;
266| 756k|}
gml.c:allocate_attributes:
322| 10.0k|) {
323| 10.0k| igraph_int_t i, n = igraph_attribute_record_list_size(attrs);
324| 16.9k| for (i = 0; i < n; i++) {
------------------
| Branch (324:17): [True: 6.90k, False: 10.0k]
------------------
325| 6.90k| igraph_attribute_record_t *atrec = igraph_attribute_record_list_get_ptr(attrs, i);
326| |
327| | /* We have unspecified attribute types in the attribute record list at
328| | * this point because we need to keep the same order in the attribute
329| | * record list as it was in the trie that we use to look up an
330| | * attribute record by name. However, we cannot resize unknown attributes
331| | * so we need to take care of this */
332| 6.90k| if (atrec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (332:13): [True: 6.90k, False: 0]
------------------
333| 6.90k| IGRAPH_CHECK(igraph_attribute_record_resize(atrec, no_of_items));
------------------
| | 656| 6.90k| do { \
| | 657| 6.90k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.90k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.90k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.90k]
| | ------------------
------------------
334| 6.90k| } else {
335| 0| IGRAPH_WARNINGF("Composite %s attribute '%s' ignored in GML file.", kind, atrec->name);
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
336| 0| }
337| 6.90k| }
338| 10.0k| return IGRAPH_SUCCESS;
339| 10.0k|}
gml.c:igraph_i_gml_toreal:
164| 47.2k|static igraph_real_t igraph_i_gml_toreal(igraph_gml_tree_t *node, igraph_int_t pos) {
165| 47.2k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, pos);
166| |
167| 47.2k| switch (type) {
168| 46.8k| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (168:5): [True: 46.8k, False: 407]
------------------
169| 46.8k| return igraph_gml_tree_get_integer(node, pos);
170| 407| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (170:5): [True: 407, False: 46.8k]
------------------
171| 407| return igraph_gml_tree_get_real(node, pos);
172| 0| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (172:5): [True: 0, False: 47.2k]
------------------
173| 0| return IGRAPH_NAN; /* default value of NaN when composite is ignored */
------------------
| | 138| 0|#define IGRAPH_NAN ((double)NAN)
------------------
174| 0| default:
------------------
| Branch (174:5): [True: 0, False: 47.2k]
------------------
175| | /* Must never reach here, regardless of the contents of the GML file. */
176| 0| IGRAPH_FATALF("Unexpected node type in GML tree, line %" IGRAPH_PRId ".",
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
177| 47.2k| igraph_gml_tree_line(node, pos)); /* LCOV_EXCL_LINE */
178| 47.2k| }
179| 47.2k|}
gml.c:igraph_i_gml_tostring:
181| 367k|static const char *igraph_i_gml_tostring(igraph_gml_tree_t *node, igraph_int_t pos) {
182| 367k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, pos);
183| 367k| static char tmp[100];
184| 367k| const char *p = tmp;
185| 367k| igraph_int_t i;
186| 367k| igraph_real_t d;
187| |
188| 367k| switch (type) {
189| 196| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (189:5): [True: 196, False: 367k]
------------------
190| 196| i = igraph_gml_tree_get_integer(node, pos);
191| 196| snprintf(tmp, sizeof(tmp) / sizeof(char), "%" IGRAPH_PRId, i);
------------------
| | 63| 196|# define IGRAPH_PRId PRId64
------------------
192| 196| break;
193| 494| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (193:5): [True: 494, False: 366k]
------------------
194| 494| d = igraph_gml_tree_get_real(node, pos);
195| 494| igraph_real_snprintf_precise(tmp, sizeof(tmp) / sizeof(char), d);
196| 494| break;
197| 366k| case IGRAPH_I_GML_TREE_STRING:
------------------
| Branch (197:5): [True: 366k, False: 690]
------------------
198| 366k| p = igraph_gml_tree_get_string(node, pos);
199| 366k| break;
200| 0| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (200:5): [True: 0, False: 367k]
------------------
201| 0| tmp[0] = '\0'; /* default value of "" when composite is ignored */
202| 0| break;
203| 0| default:
------------------
| Branch (203:5): [True: 0, False: 367k]
------------------
204| | /* Must never reach here, regardless of the contents of the GML file. */
205| 0| IGRAPH_FATALF("Unexpected node type in GML tree, line %" IGRAPH_PRId ".",
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
206| 367k| igraph_gml_tree_line(node, pos)); /* LCOV_EXCL_LINE */
207| 367k| }
208| |
209| 367k| return p;
210| 367k|}
gml.c:needs_coding:
54| 737k|static igraph_bool_t needs_coding(const char *str) {
55| 37.3M| while (*str) {
------------------
| Branch (55:12): [True: 36.6M, False: 722k]
------------------
56| 36.6M| if (*str == '&' || *str == '"') {
------------------
| Branch (56:13): [True: 8.17k, False: 36.6M]
| Branch (56:28): [True: 6.96k, False: 36.6M]
------------------
57| 15.1k| return true;
58| 15.1k| }
59| 36.6M| str++;
60| 36.6M| }
61| 722k| return false;
62| 737k|}
gml.c:entity_decode:
110| 7.56k|static igraph_error_t entity_decode(const char *src, char **dest, igraph_bool_t *warned) {
111| 7.56k| const char *entity_names[] = {
112| 7.56k| """, "&", "'", "<", ">"
113| 7.56k| };
114| |
115| 7.56k| const char entity_values[] = {
116| 7.56k| '"', '&', '\'', '<', '>'
117| 7.56k| };
118| |
119| 7.56k| const int entity_count = sizeof entity_values / sizeof entity_values[0];
120| |
121| 7.56k| const char *s;
122| 7.56k| char *d;
123| 7.56k| size_t len = strlen(src);
124| 7.56k| *dest = IGRAPH_CALLOC(len+1, char); /* at most as much storage needed as for 'src' */
------------------
| | 33| 7.56k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 15.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 7.56k, False: 0]
| | | | | Branch (31:24): [True: 7.56k, False: 0]
| | | | | Branch (31:66): [True: 7.56k, False: 0]
| | | | ------------------
| | ------------------
------------------
125| 7.56k| IGRAPH_CHECK_OOM(dest, "Not enough memory to decode string during GML import.");
------------------
| | 709| 7.56k| do { \
| | 710| 7.56k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 7.56k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.56k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 7.56k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 7.56k]
| | ------------------
------------------
126| |
127| 74.9M| for (s = src, d = *dest; *s != '\0';) {
------------------
| Branch (127:30): [True: 74.8M, False: 7.56k]
------------------
128| 74.8M| if (*s == '&') {
------------------
| Branch (128:13): [True: 14.1M, False: 60.7M]
------------------
129| 14.1M| int i;
130| 14.1M| for (i=0; i < entity_count; i++) {
------------------
| Branch (130:23): [True: 14.1M, False: 0]
------------------
131| 14.1M| size_t entity_len = strlen(entity_names[i]);
132| 14.1M| if (!strncasecmp(s, entity_names[i], entity_len)) {
------------------
| Branch (132:21): [True: 14.1M, False: 1.59k]
------------------
133| 14.1M| *d++ = entity_values[i];
134| 14.1M| s += entity_len;
135| 14.1M| break;
136| 14.1M| }
137| 14.1M| }
138| | /* None of the known entities match, report warning and pass through unchanged. */
139| 14.1M| if (i == entity_count) {
------------------
| Branch (139:17): [True: 0, False: 14.1M]
------------------
140| 0| if (! *warned) {
------------------
| Branch (140:21): [True: 0, False: 0]
------------------
141| 0| const int max_entity_name_length = 34;
142| 0| int j = 0;
143| 0| while (s[j] != '\0' && s[j] != ';' && j < max_entity_name_length) {
------------------
| Branch (143:28): [True: 0, False: 0]
| Branch (143:44): [True: 0, False: 0]
| Branch (143:59): [True: 0, False: 0]
------------------
144| 0| j++;
145| 0| }
146| 0| if (s[j] == '\0' || j == max_entity_name_length) {
------------------
| Branch (146:25): [True: 0, False: 0]
| Branch (146:41): [True: 0, False: 0]
------------------
147| 0| IGRAPH_WARNING("Unterminated entity or stray & character found, will be returned verbatim.");
------------------
| | 797| 0| do { \
| | 798| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 0| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 0]
| | ------------------
------------------
148| 0| } else {
149| 0| IGRAPH_WARNINGF("One or more unknown entities will be returned verbatim (%.*s).", j+1, s);
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
150| 0| }
151| 0| *warned = true; /* warn only once */
152| 0| }
153| 0| *d++ = *s++;
154| 0| }
155| 60.7M| } else {
156| 60.7M| *d++ = *s++;
157| 60.7M| }
158| 74.8M| }
159| 7.56k| *d = '\0';
160| |
161| 7.56k| return IGRAPH_SUCCESS;
162| 7.56k|}
gml.c:prune_unknown_attributes:
236| 10.0k|static igraph_error_t prune_unknown_attributes(igraph_attribute_record_list_t *attrs) {
237| 10.0k| igraph_int_t i, n;
238| 10.0k| igraph_vector_int_t to_remove;
239| |
240| 10.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&to_remove, 0);
------------------
| | 119| 10.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 10.0k| do { \
| | | | 657| 10.0k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 10.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 10.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 10.0k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 10.0k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 10.0k]
| | | | ------------------
| | ------------------
| | 120| 10.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 10.0k| do { \
| | | | 604| 10.0k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 10.0k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 10.0k| * incorrect destructor function with the pointer */ \
| | | | 607| 10.0k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 10.0k]
| | | | ------------------
| | | | 608| 10.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 10.0k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 10.0k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 10.0k]
| | ------------------
------------------
241| |
242| 10.0k| n = igraph_attribute_record_list_size(attrs);
243| 16.9k| for (i = 0; i < n; i++) {
------------------
| Branch (243:17): [True: 6.90k, False: 10.0k]
------------------
244| 6.90k| igraph_attribute_record_t *atrec = igraph_attribute_record_list_get_ptr(attrs, i);
245| 6.90k| if (atrec->type == IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (245:13): [True: 0, False: 6.90k]
------------------
246| 0| IGRAPH_CHECK(igraph_vector_int_push_back(&to_remove, i));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
247| 0| }
248| 6.90k| }
249| |
250| 10.0k| n = igraph_vector_int_size(&to_remove);
251| 10.0k| for (i = n - 1; i >= 0; i--) {
------------------
| Branch (251:21): [True: 0, False: 10.0k]
------------------
252| 0| igraph_attribute_record_list_discard(attrs, VECTOR(to_remove)[i]);
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
253| 0| }
254| |
255| 10.0k| igraph_vector_int_destroy(&to_remove);
256| 10.0k| IGRAPH_FINALLY_CLEAN(1);
257| |
258| 10.0k| return IGRAPH_SUCCESS;
259| 10.0k|}
gml.c:entity_encode:
67| 7.56k|static igraph_error_t entity_encode(const char *src, char **dest, igraph_bool_t only_quot) {
68| 7.56k| igraph_int_t destlen = 0;
69| 7.56k| const char *s;
70| 7.56k| char *d;
71| |
72| 74.9M| for (s = src; *s != '\0'; s++, destlen++) {
------------------
| Branch (72:19): [True: 74.8M, False: 7.56k]
------------------
73| 74.8M| switch (*s) {
------------------
| Branch (73:17): [True: 14.1M, False: 60.7M]
------------------
74| 1.59k| case '&': /* & */
------------------
| Branch (74:9): [True: 1.59k, False: 74.8M]
------------------
75| 1.59k| if (! only_quot) {
------------------
| Branch (75:17): [True: 1.59k, False: 0]
------------------
76| 1.59k| destlen += 4;
77| 1.59k| }
78| 1.59k| break;
79| 14.1M| case '"': /* " */
------------------
| Branch (79:9): [True: 14.1M, False: 60.7M]
------------------
80| 14.1M| destlen += 5; break;
81| 74.8M| }
82| 74.8M| }
83| 7.56k| *dest = IGRAPH_CALLOC(destlen + 1, char);
------------------
| | 33| 7.56k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 15.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 7.56k, False: 0]
| | | | | Branch (31:24): [True: 7.56k, False: 0]
| | | | | Branch (31:66): [True: 7.56k, False: 0]
| | | | ------------------
| | ------------------
------------------
84| 7.56k| IGRAPH_CHECK_OOM(dest, "Not enough memory to encode string for GML export.");
------------------
| | 709| 7.56k| do { \
| | 710| 7.56k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 7.56k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.56k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 7.56k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 7.56k]
| | ------------------
------------------
85| 74.9M| for (s = src, d = *dest; *s != '\0'; s++, d++) {
------------------
| Branch (85:30): [True: 74.8M, False: 7.56k]
------------------
86| 74.8M| switch (*s) {
87| 1.59k| case '&':
------------------
| Branch (87:9): [True: 1.59k, False: 74.8M]
------------------
88| 1.59k| if (! only_quot) {
------------------
| Branch (88:17): [True: 1.59k, False: 0]
------------------
89| 1.59k| strcpy(d, "&");
90| 1.59k| d += 4;
91| 1.59k| } else {
92| 0| *d = *s;
93| 0| }
94| 1.59k| break;
95| 14.1M| case '"':
------------------
| Branch (95:9): [True: 14.1M, False: 60.7M]
------------------
96| 14.1M| strcpy(d, """); d += 5; break;
97| 60.7M| default:
------------------
| Branch (97:9): [True: 60.7M, False: 14.1M]
------------------
98| 60.7M| *d = *s;
99| 74.8M| }
100| 74.8M| }
101| 7.56k| *d = '\0';
102| 7.56k| return IGRAPH_SUCCESS;
103| 7.56k|}
gml.c:igraph_i_vector_is_duplicate_free:
821| 48|static igraph_error_t igraph_i_vector_is_duplicate_free(const igraph_vector_t *v, igraph_bool_t *res) {
822| 48| igraph_vector_t u;
823| 48| igraph_int_t n = igraph_vector_size(v);
824| |
825| 48| if (n < 2) {
------------------
| Branch (825:9): [True: 11, False: 37]
------------------
826| 11| *res = true;
827| 11| return IGRAPH_SUCCESS;
828| 11| }
829| |
830| 37| IGRAPH_CHECK(igraph_vector_init_copy(&u, v));
------------------
| | 656| 37| do { \
| | 657| 37| igraph_error_t igraph_i_ret = (expr); \
| | 658| 37| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 37| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 37]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 37| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 37]
| | ------------------
------------------
831| 37| IGRAPH_FINALLY(igraph_vector_destroy, &u);
------------------
| | 603| 37| do { \
| | 604| 37| /* the following branch makes the compiler check the compatibility of \
| | 605| 37| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 37| * incorrect destructor function with the pointer */ \
| | 607| 37| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 37]
| | ------------------
| | 608| 37| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 37| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 37]
| | ------------------
------------------
832| 37| igraph_vector_sort(&u);
833| |
834| 37| *res = true;
835| 37| for (igraph_int_t i=1; i < n; i++) {
------------------
| Branch (835:28): [True: 37, False: 0]
------------------
836| 37| if (VECTOR(u)[i-1] == VECTOR(u)[i]) {
------------------
| | 60| 37|#define VECTOR(v) ((v).stor_begin)
------------------
if (VECTOR(u)[i-1] == VECTOR(u)[i]) {
------------------
| | 60| 37|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (836:13): [True: 37, False: 0]
------------------
837| 37| *res = false;
838| 37| break;
839| 37| }
840| 37| }
841| |
842| 37| igraph_vector_destroy(&u);
843| 37| IGRAPH_FINALLY_CLEAN(1);
844| |
845| 37| return IGRAPH_SUCCESS;
846| 37|}
gml.c:igraph_i_gml_convert_to_key:
792| 480k|static igraph_error_t igraph_i_gml_convert_to_key(const char *orig, char **key) {
793| 480k| char strno[50];
794| 480k| size_t i, len = strlen(orig), newlen = 0, plen = 0;
795| |
796| | /* do we need a prefix? */
797| 480k| if (len == 0 || !isalpha(orig[0])) {
------------------
| Branch (797:9): [True: 251, False: 479k]
| Branch (797:21): [True: 8.34k, False: 471k]
------------------
798| 8.59k| snprintf(strno, sizeof(strno) - 1, "igraph");
799| 8.59k| plen = newlen = strlen(strno);
800| 8.59k| }
801| 154M| for (i = 0; i < len; i++) {
------------------
| Branch (801:17): [True: 154M, False: 480k]
------------------
802| 154M| if (isalnum(orig[i])) {
------------------
| Branch (802:13): [True: 24.0M, False: 130M]
------------------
803| 24.0M| newlen++;
804| 24.0M| }
805| 154M| }
806| 480k| *key = IGRAPH_CALLOC(newlen + 1, char);
------------------
| | 33| 480k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 960k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 480k, False: 0]
| | | | | Branch (31:24): [True: 480k, False: 0]
| | | | | Branch (31:66): [True: 480k, False: 0]
| | | | ------------------
| | ------------------
------------------
807| 480k| IGRAPH_CHECK_OOM(*key, "Writing GML format failed.");
------------------
| | 709| 480k| do { \
| | 710| 480k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 480k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 480k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 480k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 480k]
| | ------------------
------------------
808| 480k| memcpy(*key, strno, plen * sizeof(char));
809| 154M| for (i = 0; i < len; i++) {
------------------
| Branch (809:17): [True: 154M, False: 480k]
------------------
810| 154M| if (isalnum(orig[i])) {
------------------
| Branch (810:13): [True: 24.0M, False: 130M]
------------------
811| 24.0M| (*key)[plen++] = orig[i];
812| 24.0M| }
813| 154M| }
814| 480k| (*key)[newlen] = '\0';
815| |
816| 480k| return IGRAPH_SUCCESS;
817| 480k|}
igraph_read_graph_graphml:
1471| 23.2k|igraph_error_t igraph_read_graph_graphml(igraph_t *graph, FILE *instream, igraph_int_t index) {
1472| |
1473| 23.2k|#if HAVE_LIBXML == 1
1474| 23.2k| xmlParserCtxtPtr ctxt;
1475| 23.2k| xmlGenericErrorFunc libxml_old_generic_error_handler;
1476| 23.2k| void* libxml_old_generic_error_context;
1477| 23.2k| xmlStructuredErrorFunc libxml_old_structured_error_handler;
1478| 23.2k| void* libxml_old_structured_error_context;
1479| 23.2k| xmlDocPtr doc;
1480| |
1481| 23.2k| struct igraph_i_graphml_parser_state state;
1482| 23.2k| int res;
1483| 23.2k| char buffer[4096];
1484| 23.2k| igraph_bool_t parsing_successful;
1485| 23.2k| char* error_message;
1486| |
1487| 23.2k| if (index < 0) {
------------------
| Branch (1487:9): [True: 0, False: 23.2k]
------------------
1488| 0| IGRAPH_ERROR("Graph index must be non-negative.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1489| 0| }
1490| |
1491| 23.2k| xmlInitParser();
1492| |
1493| 23.2k| IGRAPH_CHECK(igraph_i_graphml_parser_state_init(&state, graph, index));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
1494| 23.2k| IGRAPH_FINALLY(igraph_i_graphml_parser_state_destroy, &state);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
1495| |
1496| | /* Create a progressive parser context and use the first 4K to detect the
1497| | * encoding */
1498| 23.2k| res = (int) fread(buffer, 1, sizeof(buffer), instream);
1499| 23.2k| if (res < (int) sizeof buffer && !feof(instream)) {
------------------
| Branch (1499:9): [True: 19.6k, False: 3.51k]
| Branch (1499:38): [True: 0, False: 19.6k]
------------------
1500| 0| IGRAPH_ERROR("IO error while reading GraphML data.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1501| 0| }
1502| |
1503| | /* Retrieve the current libxml2 error handlers and temporarily replace them
1504| | * with ones that do not print anything to stdout/stderr */
1505| 23.2k| libxml_old_generic_error_handler = xmlGenericError;
------------------
| | 976| 23.2k| #define xmlGenericError (*__xmlGenericError())
------------------
1506| 23.2k| libxml_old_generic_error_context = xmlGenericErrorContext;
------------------
| | 983| 23.2k| #define xmlGenericErrorContext (*__xmlGenericErrorContext())
------------------
1507| 23.2k| libxml_old_structured_error_handler = xmlStructuredError;
------------------
| | 990| 23.2k| #define xmlStructuredError (*__xmlStructuredError())
------------------
1508| 23.2k| libxml_old_structured_error_context = xmlStructuredErrorContext;
------------------
| | 997| 23.2k| #define xmlStructuredErrorContext (*__xmlStructuredErrorContext())
------------------
1509| 23.2k| xmlSetGenericErrorFunc(&state, &igraph_i_libxml_generic_error_handler);
1510| 23.2k| xmlSetStructuredErrorFunc(&state, &igraph_i_libxml_structured_error_handler);
1511| |
1512| | /* Okay, parsing will start now. The parser might do things that eventually
1513| | * trigger the igraph error handler, but we want the parser state to
1514| | * survive whatever happens here. So, we put a barrier on the FINALLY stack
1515| | * that prevents IGRAPH_ERROR() from freeing the parser state, and then we
1516| | * do this ourselves when needed */
1517| 23.2k| IGRAPH_FINALLY_ENTER();
1518| 23.2k| {
1519| 23.2k| ctxt = xmlCreatePushParserCtxt(&igraph_i_graphml_sax_handler,
1520| 23.2k| &state,
1521| 23.2k| buffer,
1522| 23.2k| res,
1523| 23.2k| NULL);
1524| 23.2k| if (ctxt) {
------------------
| Branch (1524:13): [True: 23.2k, False: 0]
------------------
1525| 23.2k| if (xmlCtxtUseOptions(ctxt,
------------------
| Branch (1525:17): [True: 0, False: 23.2k]
------------------
1526| 23.2k| XML_PARSE_NOBLANKS |
1527| 23.2k| XML_PARSE_NONET | XML_PARSE_NSCLEAN |
1528| 23.2k| XML_PARSE_NOCDATA | XML_PARSE_HUGE
1529| 23.2k| )) {
1530| 0| xmlFreeParserCtxt(ctxt);
1531| 0| ctxt = NULL;
1532| 0| }
1533| 23.2k| }
1534| |
1535| | /* Do the parsing */
1536| 23.2k| if (ctxt) {
------------------
| Branch (1536:13): [True: 23.2k, False: 0]
------------------
1537| 414k| while ((res = (int) fread(buffer, 1, sizeof buffer, instream)) > 0) {
------------------
| Branch (1537:20): [True: 392k, False: 22.7k]
------------------
1538| 392k| xmlParseChunk(ctxt, buffer, res, 0);
1539| 392k| if (!state.successful) {
------------------
| Branch (1539:21): [True: 461, False: 391k]
------------------
1540| 461| break;
1541| 461| }
1542| 391k| IGRAPH_ALLOW_INTERRUPTION();
------------------
| | 46| 391k| do { \
| | 47| 391k| if (igraph_i_interruption_handler) { \
| | ------------------
| | | Branch (47:13): [True: 0, False: 391k]
| | ------------------
| | 48| 0| if (igraph_allow_interruption()) { \
| | ------------------
| | | Branch (48:17): [True: 0, False: 0]
| | ------------------
| | 49| 0| return IGRAPH_INTERRUPTED; \
| | 50| 0| } \
| | 51| 0| } \
| | 52| 391k| } while (0)
| | ------------------
| | | Branch (52:14): [Folded, False: 391k]
| | ------------------
------------------
1543| 391k| }
1544| 23.2k| xmlParseChunk(ctxt, buffer, res, 1);
1545| 23.2k| }
1546| 23.2k| }
1547| 23.2k| IGRAPH_FINALLY_EXIT();
1548| |
1549| | /* Restore error handlers */
1550| 23.2k| xmlSetGenericErrorFunc(libxml_old_generic_error_context, libxml_old_generic_error_handler);
1551| 23.2k| xmlSetStructuredErrorFunc(libxml_old_structured_error_context, libxml_old_structured_error_handler);
1552| |
1553| | /* Free the context */
1554| 23.2k| if (ctxt) {
------------------
| Branch (1554:9): [True: 23.2k, False: 0]
------------------
1555| 23.2k| doc = ctxt->myDoc;
1556| 23.2k| xmlFreeParserCtxt(ctxt);
1557| 23.2k| if (doc) {
------------------
| Branch (1557:13): [True: 1.37k, False: 21.8k]
------------------
1558| | /* In theory this should not be necessary, but it looks like certain malformed
1559| | * GraphML files leave a partially-parsed doc in memory */
1560| 1.37k| xmlFreeDoc(doc);
1561| 1.37k| }
1562| 23.2k| } else {
1563| | /* We could not create the context earlier so no parsing was done */
1564| 0| IGRAPH_ERROR("Cannot create XML parser context.", IGRAPH_FAILURE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1565| 0| }
1566| |
1567| | /* Extract the error message from the parser state (if any), and make a
1568| | * copy so we can safely destroy the parser state before triggering the
1569| | * error */
1570| 23.2k| parsing_successful = state.successful;
1571| 23.2k| error_message = parsing_successful || state.error_message == NULL ? NULL : strdup(state.error_message);
------------------
| Branch (1571:21): [True: 6.68k, False: 16.5k]
| Branch (1571:43): [True: 0, False: 16.5k]
------------------
1572| |
1573| | /* ...and we can also put the error message pointer on the FINALLY stack */
1574| 23.2k| if (error_message != NULL) {
------------------
| Branch (1574:9): [True: 16.5k, False: 6.68k]
------------------
1575| 16.5k| IGRAPH_FINALLY(igraph_free, error_message);
------------------
| | 603| 16.5k| do { \
| | 604| 16.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.5k| * incorrect destructor function with the pointer */ \
| | 607| 16.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.5k]
| | ------------------
| | 608| 16.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.5k]
| | ------------------
------------------
1576| 16.5k| }
1577| |
1578| | /* Trigger the stored error if needed */
1579| 23.2k| if (!parsing_successful) {
------------------
| Branch (1579:9): [True: 16.5k, False: 6.68k]
------------------
1580| 16.5k| if (error_message != NULL) {
------------------
| Branch (1580:13): [True: 16.5k, False: 0]
------------------
1581| 16.5k| size_t len = strlen(error_message);
1582| 16.5k| if (error_message[len-1] == '\n') {
------------------
| Branch (1582:17): [True: 16.1k, False: 385]
------------------
1583| 16.1k| error_message[len-1] = '\0';
1584| 16.1k| }
1585| 16.5k| IGRAPH_ERROR(error_message, IGRAPH_PARSEERROR);
------------------
| | 426| 16.5k| do { \
| | 427| 16.5k| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 16.5k| return igraph_errno ; \
| | 429| 16.5k| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1586| 16.5k| } else {
1587| 0| IGRAPH_ERROR("Malformed GraphML file.", IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1588| 0| }
1589| 16.5k| }
1590| |
1591| | /* Did we actually manage to reach the graph to be parsed, given its index?
1592| | * If not, that's an error as well. */
1593| 6.68k| if (state.index >= 0) {
------------------
| Branch (1593:9): [True: 39, False: 6.64k]
------------------
1594| 39| IGRAPH_ERROR("Graph index was too large.", IGRAPH_EINVAL);
------------------
| | 426| 39| do { \
| | 427| 39| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 39| return igraph_errno ; \
| | 429| 39| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1595| 39| }
1596| |
1597| | /* Okay, everything seems good. We can now take the parser state and
1598| | * construct our graph from the data gathered during the parsing */
1599| 6.64k| IGRAPH_CHECK(igraph_i_graphml_parser_state_finish_parsing(&state));
------------------
| | 656| 6.64k| do { \
| | 657| 6.64k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.64k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.64k]
| | ------------------
------------------
1600| |
1601| 6.64k| igraph_i_graphml_parser_state_destroy(&state);
1602| 6.64k| IGRAPH_FINALLY_CLEAN(1);
1603| |
1604| 6.64k| return IGRAPH_SUCCESS;
1605| |#else // HAVE_LIBXML == 1
1606| | IGRAPH_UNUSED(graph);
1607| | IGRAPH_UNUSED(instream);
1608| | IGRAPH_UNUSED(index);
1609| |
1610| | IGRAPH_ERROR("GraphML support is disabled.", IGRAPH_UNIMPLEMENTED);
1611| |#endif // HAVE_LIBXML == 1
1612| 6.64k|}
igraph_write_graph_graphml:
1649| 3.34k| igraph_bool_t prefixattr) {
1650| 3.34k| int ret;
1651| 3.34k| igraph_int_t l, vc;
1652| 3.34k| igraph_eit_t it;
1653| 3.34k| igraph_strvector_t gnames, vnames, enames;
1654| 3.34k| igraph_vector_int_t gtypes, vtypes, etypes;
1655| 3.34k| igraph_int_t i;
1656| 3.34k| igraph_vector_t numv;
1657| 3.34k| igraph_strvector_t strv;
1658| 3.34k| igraph_vector_bool_t boolv;
1659| 3.34k| const char *gprefix = prefixattr ? "g_" : "";
------------------
| Branch (1659:27): [True: 0, False: 3.34k]
------------------
1660| 3.34k| const char *vprefix = prefixattr ? "v_" : "";
------------------
| Branch (1660:27): [True: 0, False: 3.34k]
------------------
1661| 3.34k| const char *eprefix = prefixattr ? "e_" : "";
------------------
| Branch (1661:27): [True: 0, False: 3.34k]
------------------
1662| 3.34k| char what[100];
1663| |
1664| 3.34k| ret = fprintf(outstream, "\n");
1665| 3.34k| if (ret < 0) {
------------------
| Branch (1665:9): [True: 0, False: 3.34k]
------------------
1666| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1667| 0| }
1668| 3.34k| ret = fprintf(outstream, "\n", GRAPHML_NAMESPACE_URI);
------------------
| | 38| 3.34k|#define GRAPHML_NAMESPACE_URI "http://graphml.graphdrawing.org/xmlns"
------------------
1681| 3.34k| if (ret < 0) {
------------------
| Branch (1681:9): [True: 0, False: 3.34k]
------------------
1682| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1683| 0| }
1684| 3.34k| ret = fprintf(outstream, "\n");
1685| 3.34k| if (ret < 0) {
------------------
| Branch (1685:9): [True: 0, False: 3.34k]
------------------
1686| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1687| 0| }
1688| |
1689| | /* dump the elements if any */
1690| |
1691| 3.34k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.34k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 105| 3.34k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.34k]
| | ------------------
------------------
1692| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
1693| 3.34k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);
------------------
| | 109| 3.34k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 110| 3.34k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.34k]
| | ------------------
------------------
1694| |
1695| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
1696| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
1697| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
1698| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
1699| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
1700| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
1701| 3.34k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
1702| 3.34k| &gnames, >ypes,
1703| 3.34k| &vnames, &vtypes,
1704| 3.34k| &enames, &etypes));
1705| |
1706| | /* graph attributes */
1707| 4.18k| for (i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (1707:17): [True: 849, False: 3.34k]
------------------
1708| 849| const char *name; char *name_escaped;
1709| 849| name = igraph_strvector_get(&gnames, i);
1710| 849| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 849| do { \
| | 657| 849| igraph_error_t igraph_i_ret = (expr); \
| | 658| 849| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 849| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 849]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 849| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 849]
| | ------------------
------------------
1711| 849| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 603| 849| do { \
| | 604| 849| /* the following branch makes the compiler check the compatibility of \
| | 605| 849| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 849| * incorrect destructor function with the pointer */ \
| | 607| 849| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 849]
| | ------------------
| | 608| 849| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 849| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 849]
| | ------------------
------------------
1712| 849| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 849|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1712:13): [True: 599, False: 250]
------------------
1713| 599| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1714| 599| if (ret < 0) {
------------------
| Branch (1714:17): [True: 0, False: 599]
------------------
1715| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1716| 0| }
1717| 599| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 250|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1717:20): [True: 110, False: 140]
------------------
1718| 110| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1719| 110| if (ret < 0) {
------------------
| Branch (1719:17): [True: 0, False: 110]
------------------
1720| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1721| 0| }
1722| 140| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 140|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1722:20): [True: 140, False: 0]
------------------
1723| 140| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1724| 140| if (ret < 0) {
------------------
| Branch (1724:17): [True: 0, False: 140]
------------------
1725| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1726| 0| }
1727| 140| }
1728| 849| IGRAPH_FREE(name_escaped);
------------------
| | 36| 849|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1729| 849| IGRAPH_FINALLY_CLEAN(1);
1730| 849| }
1731| |
1732| | /* vertex attributes */
1733| 8.44k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1733:17): [True: 5.10k, False: 3.34k]
------------------
1734| 5.10k| const char *name; char *name_escaped;
1735| 5.10k| name = igraph_strvector_get(&vnames, i);
1736| 5.10k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 5.10k| do { \
| | 657| 5.10k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.10k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.10k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.10k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.10k]
| | ------------------
------------------
1737| 5.10k| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 603| 5.10k| do { \
| | 604| 5.10k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.10k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.10k| * incorrect destructor function with the pointer */ \
| | 607| 5.10k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.10k]
| | ------------------
| | 608| 5.10k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.10k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.10k]
| | ------------------
------------------
1738| 5.10k| if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 5.10k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1738:13): [True: 4.27k, False: 832]
------------------
1739| 4.27k| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1740| 4.27k| if (ret < 0) {
------------------
| Branch (1740:17): [True: 0, False: 4.27k]
------------------
1741| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1742| 0| }
1743| 4.27k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 832|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1743:20): [True: 299, False: 533]
------------------
1744| 299| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1745| 299| if (ret < 0) {
------------------
| Branch (1745:17): [True: 0, False: 299]
------------------
1746| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1747| 0| }
1748| 533| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 533|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1748:20): [True: 533, False: 0]
------------------
1749| 533| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1750| 533| if (ret < 0) {
------------------
| Branch (1750:17): [True: 0, False: 533]
------------------
1751| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1752| 0| }
1753| 533| }
1754| 5.10k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 5.10k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1755| 5.10k| IGRAPH_FINALLY_CLEAN(1);
1756| 5.10k| }
1757| |
1758| | /* edge attributes */
1759| 6.10k| for (i = 0; i < igraph_vector_int_size(&etypes); i++) {
------------------
| Branch (1759:17): [True: 2.76k, False: 3.34k]
------------------
1760| 2.76k| const char *name; char *name_escaped;
1761| 2.76k| name = igraph_strvector_get(&enames, i);
1762| 2.76k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 2.76k| do { \
| | 657| 2.76k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.76k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.76k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.76k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.76k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.76k]
| | ------------------
------------------
1763| 2.76k| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 603| 2.76k| do { \
| | 604| 2.76k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.76k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.76k| * incorrect destructor function with the pointer */ \
| | 607| 2.76k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.76k]
| | ------------------
| | 608| 2.76k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.76k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.76k]
| | ------------------
------------------
1764| 2.76k| if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 2.76k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1764:13): [True: 1.82k, False: 943]
------------------
1765| 1.82k| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1766| 1.82k| if (ret < 0) {
------------------
| Branch (1766:17): [True: 0, False: 1.82k]
------------------
1767| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1768| 0| }
1769| 1.82k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 943|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1769:20): [True: 435, False: 508]
------------------
1770| 435| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1771| 435| if (ret < 0) {
------------------
| Branch (1771:17): [True: 0, False: 435]
------------------
1772| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1773| 0| }
1774| 508| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 508|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1774:20): [True: 508, False: 0]
------------------
1775| 508| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1776| 508| if (ret < 0) {
------------------
| Branch (1776:17): [True: 0, False: 508]
------------------
1777| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1778| 0| }
1779| 508| }
1780| 2.76k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 2.76k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1781| 2.76k| IGRAPH_FINALLY_CLEAN(1);
1782| 2.76k| }
1783| |
1784| 3.34k| ret = fprintf(outstream, " \n", (igraph_is_directed(graph) ? "directed" : "undirected"));
------------------
| Branch (1784:74): [True: 137, False: 3.20k]
------------------
1785| 3.34k| if (ret < 0) {
------------------
| Branch (1785:9): [True: 0, False: 3.34k]
------------------
1786| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1787| 0| }
1788| |
1789| | /* Write the graph atributes before anything else */
1790| |
1791| 4.18k| for (i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (1791:17): [True: 849, False: 3.34k]
------------------
1792| 849| const char *name; char *name_escaped;
1793| 849| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 849|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1793:13): [True: 110, False: 739]
------------------
1794| 110| name = igraph_strvector_get(&gnames, i);
1795| 110| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 110| do { \
| | 657| 110| igraph_error_t igraph_i_ret = (expr); \
| | 658| 110| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 110| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 110]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 110| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 110]
| | ------------------
------------------
1796| 110| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1796:17): [True: 38, False: 72]
------------------
1797| 38| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 38| do { \
| | 657| 38| igraph_error_t igraph_i_ret = (expr); \
| | 658| 38| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 38| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 38]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 38| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 38]
| | ------------------
------------------
1798| 38| ret = fprintf(outstream, " ", gprefix, name_escaped);
1799| 38| IGRAPH_FREE(name_escaped);
------------------
| | 36| 38|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1800| 38| if (ret < 0) {
------------------
| Branch (1800:21): [True: 0, False: 38]
------------------
1801| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1802| 0| }
1803| 38| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 38|#define VECTOR(v) ((v).stor_begin)
------------------
1804| 38| if (ret < 0) {
------------------
| Branch (1804:21): [True: 0, False: 38]
------------------
1805| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1806| 0| }
1807| 38| ret = fprintf(outstream, "\n");
1808| 38| if (ret < 0) {
------------------
| Branch (1808:21): [True: 0, False: 38]
------------------
1809| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1810| 0| }
1811| 38| }
1812| 739| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 739|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1812:20): [True: 599, False: 140]
------------------
1813| 599| const char *s;
1814| 599| char *s_escaped;
1815| 599| name = igraph_strvector_get(&gnames, i);
1816| 599| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 599| do { \
| | 657| 599| igraph_error_t igraph_i_ret = (expr); \
| | 658| 599| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 599]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 599| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 599]
| | ------------------
------------------
1817| 599| ret = fprintf(outstream, " ", gprefix,
1818| 599| name_escaped);
1819| 599| IGRAPH_FREE(name_escaped);
------------------
| | 36| 599|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1820| 599| if (ret < 0) {
------------------
| Branch (1820:17): [True: 0, False: 599]
------------------
1821| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1822| 0| }
1823| 599| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 599| do { \
| | 657| 599| igraph_error_t igraph_i_ret = (expr); \
| | 658| 599| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 599]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 599| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 599]
| | ------------------
------------------
1824| 599| s = igraph_strvector_get(&strv, 0);
1825| 599| snprintf(what, sizeof(what) / sizeof(what[0]), "the value of the '%s' graph attribute", name);
1826| 599| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 599| do { \
| | 657| 599| igraph_error_t igraph_i_ret = (expr); \
| | 658| 599| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 599]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 599| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 599]
| | ------------------
------------------
1827| 599| ret = fprintf(outstream, "%s", s_escaped);
1828| 599| IGRAPH_FREE(s_escaped);
------------------
| | 36| 599|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1829| 599| if (ret < 0) {
------------------
| Branch (1829:17): [True: 0, False: 599]
------------------
1830| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1831| 0| }
1832| 599| ret = fprintf(outstream, "\n");
1833| 599| if (ret < 0) {
------------------
| Branch (1833:17): [True: 0, False: 599]
------------------
1834| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1835| 0| }
1836| 599| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 140|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1836:20): [True: 140, False: 0]
------------------
1837| 140| name = igraph_strvector_get(&gnames, i);
1838| 140| IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
------------------
| | 656| 140| do { \
| | 657| 140| igraph_error_t igraph_i_ret = (expr); \
| | 658| 140| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 140| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 140]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 140| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 140]
| | ------------------
------------------
1839| 140| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 140| do { \
| | 657| 140| igraph_error_t igraph_i_ret = (expr); \
| | 658| 140| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 140| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 140]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 140| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 140]
| | ------------------
------------------
1840| 140| ret = fprintf(outstream, " %s\n",
1841| 140| gprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 140|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1841:50): [True: 0, False: 140]
------------------
1842| 140| IGRAPH_FREE(name_escaped);
------------------
| | 36| 140|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1843| 140| if (ret < 0) {
------------------
| Branch (1843:17): [True: 0, False: 140]
------------------
1844| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1845| 0| }
1846| 140| }
1847| 849| }
1848| |
1849| | /* Let's dump the nodes first */
1850| 3.34k| vc = igraph_vcount(graph);
1851| 36.8k| for (l = 0; l < vc; l++) {
------------------
| Branch (1851:17): [True: 33.4k, False: 3.34k]
------------------
1852| 33.4k| const char *name; char *name_escaped;
1853| 33.4k| ret = fprintf(outstream, " \n", l);
1854| |
1855| 33.4k| if (ret < 0) {
------------------
| Branch (1855:13): [True: 0, False: 33.4k]
------------------
1856| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1857| 0| }
1858| |
1859| 86.1k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1859:21): [True: 52.6k, False: 33.4k]
------------------
1860| 52.6k| if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 52.6k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1860:17): [True: 5.33k, False: 47.2k]
------------------
1861| 5.33k| name = igraph_strvector_get(&vnames, i);
1862| 5.33k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name,
------------------
| | 656| 5.33k| do { \
| | 657| 5.33k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.33k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.33k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.33k]
| | ------------------
------------------
1863| 5.33k| igraph_vss_1(l), &numv));
1864| 5.33k| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1864:21): [True: 4.35k, False: 978]
------------------
1865| 4.35k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 4.35k| do { \
| | 657| 4.35k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.35k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.35k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.35k]
| | ------------------
------------------
1866| 4.35k| ret = fprintf(outstream, " ", vprefix, name_escaped);
1867| 4.35k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 4.35k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1868| 4.35k| if (ret < 0) {
------------------
| Branch (1868:25): [True: 0, False: 4.35k]
------------------
1869| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1870| 0| }
1871| 4.35k| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 4.35k|#define VECTOR(v) ((v).stor_begin)
------------------
1872| 4.35k| if (ret < 0) {
------------------
| Branch (1872:25): [True: 0, False: 4.35k]
------------------
1873| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1874| 0| }
1875| 4.35k| ret = fprintf(outstream, "\n");
1876| 4.35k| if (ret < 0) {
------------------
| Branch (1876:25): [True: 0, False: 4.35k]
------------------
1877| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1878| 0| }
1879| 4.35k| }
1880| 47.2k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 47.2k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1880:24): [True: 42.8k, False: 4.44k]
------------------
1881| 42.8k| const char *s;
1882| 42.8k| char *s_escaped;
1883| 42.8k| name = igraph_strvector_get(&vnames, i);
1884| 42.8k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 42.8k| do { \
| | 657| 42.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 42.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.8k]
| | ------------------
------------------
1885| 42.8k| ret = fprintf(outstream, " ", vprefix,
1886| 42.8k| name_escaped);
1887| 42.8k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 42.8k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1888| 42.8k| if (ret < 0) {
------------------
| Branch (1888:21): [True: 0, False: 42.8k]
------------------
1889| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1890| 0| }
1891| 42.8k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name,
------------------
| | 656| 42.8k| do { \
| | 657| 42.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 42.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.8k]
| | ------------------
------------------
1892| 42.8k| igraph_vss_1(l), &strv));
1893| 42.8k| s = igraph_strvector_get(&strv, 0);
1894| 42.8k| snprintf(what, sizeof(what) / sizeof(what[0]), "a value of the '%s' vertex attribute", name);
1895| 42.8k| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 42.8k| do { \
| | 657| 42.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 42.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.8k]
| | ------------------
------------------
1896| 42.8k| ret = fprintf(outstream, "%s", s_escaped);
1897| 42.8k| IGRAPH_FREE(s_escaped);
------------------
| | 36| 42.8k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1898| 42.8k| if (ret < 0) {
------------------
| Branch (1898:21): [True: 0, False: 42.8k]
------------------
1899| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1900| 0| }
1901| 42.8k| ret = fprintf(outstream, "\n");
1902| 42.8k| if (ret < 0) {
------------------
| Branch (1902:21): [True: 0, False: 42.8k]
------------------
1903| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1904| 0| }
1905| 42.8k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 4.44k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1905:24): [True: 4.44k, False: 0]
------------------
1906| 4.44k| name = igraph_strvector_get(&vnames, i);
1907| 4.44k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name,
------------------
| | 656| 4.44k| do { \
| | 657| 4.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.44k]
| | ------------------
------------------
1908| 4.44k| igraph_vss_1(l), &boolv));
1909| 4.44k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 4.44k| do { \
| | 657| 4.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.44k]
| | ------------------
------------------
1910| 4.44k| ret = fprintf(outstream, " %s\n",
1911| 4.44k| vprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 4.44k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1911:54): [True: 16, False: 4.43k]
------------------
1912| 4.44k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 4.44k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1913| 4.44k| if (ret < 0) {
------------------
| Branch (1913:21): [True: 0, False: 4.44k]
------------------
1914| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1915| 0| }
1916| 4.44k| }
1917| 52.6k| }
1918| |
1919| 33.4k| ret = fprintf(outstream, " \n");
1920| 33.4k| if (ret < 0) {
------------------
| Branch (1920:13): [True: 0, False: 33.4k]
------------------
1921| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1922| 0| }
1923| 33.4k| }
1924| |
1925| | /* Now the edges */
1926| 3.34k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &it));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
1927| 3.34k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
1928| 348k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 348k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (1928:12): [True: 344k, False: 3.34k]
------------------
1929| 344k| igraph_int_t from, to;
1930| 344k| const char *name; char *name_escaped;
1931| 344k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 344k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 344k, False: 0]
| | ------------------
| | 406| 344k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1932| |
1933| 344k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 344k| do { \
| | 657| 344k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344k]
| | ------------------
------------------
1934| 344k| ret = fprintf(outstream, " \n",
1935| 344k| from, to);
1936| 344k| if (ret < 0) {
------------------
| Branch (1936:13): [True: 0, False: 344k]
------------------
1937| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1938| 0| }
1939| |
1940| 804k| for (i = 0; i < igraph_vector_int_size(&etypes); i++) {
------------------
| Branch (1940:21): [True: 460k, False: 344k]
------------------
1941| 460k| if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 460k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1941:17): [True: 98.5k, False: 361k]
------------------
1942| 98.5k| name = igraph_strvector_get(&enames, i);
1943| 98.5k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, name,
------------------
| | 656| 98.5k| do { \
| | 657| 98.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 98.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 98.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 98.5k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 98.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 98.5k]
| | ------------------
------------------
1944| 98.5k| igraph_ess_1(edge), &numv));
1945| 98.5k| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1945:21): [True: 1.25k, False: 97.2k]
------------------
1946| 1.25k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 1.25k| do { \
| | 657| 1.25k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.25k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.25k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.25k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.25k]
| | ------------------
------------------
1947| 1.25k| ret = fprintf(outstream, " ", eprefix, name_escaped);
1948| 1.25k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 1.25k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1949| 1.25k| if (ret < 0) {
------------------
| Branch (1949:25): [True: 0, False: 1.25k]
------------------
1950| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1951| 0| }
1952| 1.25k| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 1.25k|#define VECTOR(v) ((v).stor_begin)
------------------
1953| 1.25k| if (ret < 0) {
------------------
| Branch (1953:25): [True: 0, False: 1.25k]
------------------
1954| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1955| 0| }
1956| 1.25k| ret = fprintf(outstream, "\n");
1957| 1.25k| if (ret < 0) {
------------------
| Branch (1957:25): [True: 0, False: 1.25k]
------------------
1958| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1959| 0| }
1960| 1.25k| }
1961| 361k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 361k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1961:24): [True: 354k, False: 6.71k]
------------------
1962| 354k| const char *s;
1963| 354k| char *s_escaped;
1964| 354k| name = igraph_strvector_get(&enames, i);
1965| 354k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 354k| do { \
| | 657| 354k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 354k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 354k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 354k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 354k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 354k]
| | ------------------
------------------
1966| 354k| ret = fprintf(outstream, " ", eprefix,
1967| 354k| name_escaped);
1968| 354k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 354k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1969| 354k| if (ret < 0) {
------------------
| Branch (1969:21): [True: 0, False: 354k]
------------------
1970| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1971| 0| }
1972| 354k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, name,
------------------
| | 656| 354k| do { \
| | 657| 354k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 354k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 354k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 354k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 354k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 354k]
| | ------------------
------------------
1973| 354k| igraph_ess_1(edge), &strv));
1974| 354k| s = igraph_strvector_get(&strv, 0);
1975| 354k| snprintf(what, sizeof(what) / sizeof(what[0]), "a value of the '%s' edge attribute", name);
1976| 354k| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 354k| do { \
| | 657| 354k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 354k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 354k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 354k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 354k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 354k]
| | ------------------
------------------
1977| 354k| ret = fprintf(outstream, "%s", s_escaped);
1978| 354k| IGRAPH_FREE(s_escaped);
------------------
| | 36| 354k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1979| 354k| if (ret < 0) {
------------------
| Branch (1979:21): [True: 0, False: 354k]
------------------
1980| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1981| 0| }
1982| 354k| ret = fprintf(outstream, "\n");
1983| 354k| if (ret < 0) {
------------------
| Branch (1983:21): [True: 0, False: 354k]
------------------
1984| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1985| 0| }
1986| 354k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 6.71k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1986:24): [True: 6.71k, False: 0]
------------------
1987| 6.71k| name = igraph_strvector_get(&enames, i);
1988| 6.71k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph, name,
------------------
| | 656| 6.71k| do { \
| | 657| 6.71k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.71k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.71k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.71k]
| | ------------------
------------------
1989| 6.71k| igraph_ess_1(edge), &boolv));
1990| 6.71k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 6.71k| do { \
| | 657| 6.71k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.71k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.71k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.71k]
| | ------------------
------------------
1991| 6.71k| ret = fprintf(outstream, " %s\n",
1992| 6.71k| eprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 6.71k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1992:54): [True: 0, False: 6.71k]
------------------
1993| 6.71k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 6.71k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1994| 6.71k| if (ret < 0) {
------------------
| Branch (1994:21): [True: 0, False: 6.71k]
------------------
1995| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1996| 0| }
1997| 6.71k| }
1998| 460k| }
1999| |
2000| 344k| ret = fprintf(outstream, " \n");
2001| 344k| if (ret < 0) {
------------------
| Branch (2001:13): [True: 0, False: 344k]
------------------
2002| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
2003| 0| }
2004| 344k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 344k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
2005| 344k| }
2006| 3.34k| igraph_eit_destroy(&it);
2007| 3.34k| IGRAPH_FINALLY_CLEAN(1);
2008| |
2009| 3.34k| ret = fprintf(outstream, " \n");
2010| 3.34k| if (ret < 0) {
------------------
| Branch (2010:9): [True: 0, False: 3.34k]
------------------
2011| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
2012| 0| }
2013| 3.34k| fprintf(outstream, "\n");
2014| 3.34k| if (ret < 0) {
------------------
| Branch (2014:9): [True: 0, False: 3.34k]
------------------
2015| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
2016| 0| }
2017| |
2018| 3.34k| igraph_strvector_destroy(&gnames);
2019| 3.34k| igraph_strvector_destroy(&vnames);
2020| 3.34k| igraph_strvector_destroy(&enames);
2021| 3.34k| igraph_vector_int_destroy(>ypes);
2022| 3.34k| igraph_vector_int_destroy(&vtypes);
2023| 3.34k| igraph_vector_int_destroy(&etypes);
2024| 3.34k| igraph_vector_destroy(&numv);
2025| 3.34k| igraph_strvector_destroy(&strv);
2026| 3.34k| igraph_vector_bool_destroy(&boolv);
2027| 3.34k| IGRAPH_FINALLY_CLEAN(9);
2028| |
2029| 3.34k| return IGRAPH_SUCCESS;
2030| 3.34k|}
graphml.c:igraph_i_graphml_parser_state_init:
221| 23.2k|static igraph_error_t igraph_i_graphml_parser_state_init(struct igraph_i_graphml_parser_state* state, igraph_t* graph, igraph_int_t index) {
222| 23.2k| memset(state, 0, sizeof(struct igraph_i_graphml_parser_state));
223| |
224| 23.2k| state->g = graph;
225| 23.2k| state->index = index < 0 ? 0 : index;
------------------
| Branch (225:20): [True: 0, False: 23.2k]
------------------
226| 23.2k| state->successful = 1;
227| 23.2k| state->error_message = NULL;
228| |
229| 23.2k| IGRAPH_CHECK(igraph_vector_int_init(&state->prev_state_stack, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
230| 23.2k| IGRAPH_CHECK(igraph_vector_int_reserve(&state->prev_state_stack, 32));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
231| 23.2k| IGRAPH_FINALLY(igraph_vector_int_destroy, &state->prev_state_stack);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
232| |
233| 23.2k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->v_attrs, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
234| 23.2k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->v_attrs,
------------------
| | 94| 23.2k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
235| 23.2k| igraph_i_graphml_attribute_record_destroy);
236| 23.2k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->v_attrs);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
237| |
238| 23.2k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->e_attrs, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
239| 23.2k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->e_attrs,
------------------
| | 94| 23.2k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
240| 23.2k| igraph_i_graphml_attribute_record_destroy);
241| 23.2k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->e_attrs);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
242| |
243| 23.2k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->g_attrs, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
244| 23.2k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->g_attrs,
------------------
| | 94| 23.2k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
245| 23.2k| igraph_i_graphml_attribute_record_destroy);
246| 23.2k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->g_attrs);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
247| |
248| 23.2k| IGRAPH_CHECK(igraph_vector_int_init(&state->edgelist, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
249| 23.2k| IGRAPH_FINALLY(igraph_vector_int_destroy, &state->edgelist);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
250| |
251| 23.2k| IGRAPH_CHECK(igraph_trie_init(&state->node_trie, 1));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
252| 23.2k| IGRAPH_FINALLY(igraph_trie_destroy, &state->node_trie);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
253| |
254| 23.2k| IGRAPH_CHECK(igraph_strvector_init(&state->edgeids, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
255| 23.2k| IGRAPH_FINALLY(igraph_strvector_destroy, &state->edgeids);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
256| |
257| 23.2k| IGRAPH_CHECK(igraph_trie_init(&state->v_attr_ids, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
258| 23.2k| IGRAPH_FINALLY(igraph_trie_destroy, &state->v_attr_ids);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
259| |
260| 23.2k| IGRAPH_CHECK(igraph_trie_init(&state->e_attr_ids, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
261| 23.2k| IGRAPH_FINALLY(igraph_trie_destroy, &state->e_attr_ids);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
262| |
263| 23.2k| IGRAPH_CHECK(igraph_trie_init(&state->g_attr_ids, 0));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
264| 23.2k| IGRAPH_FINALLY(igraph_trie_destroy, &state->g_attr_ids);
------------------
| | 603| 23.2k| do { \
| | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | 607| 23.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 23.2k]
| | ------------------
| | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 23.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 23.2k]
| | ------------------
------------------
265| |
266| 23.2k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&state->data_char, 0);
------------------
| | 114| 23.2k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 23.2k| do { \
| | | | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 23.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 23.2k]
| | | | ------------------
| | ------------------
| | 115| 23.2k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 23.2k| do { \
| | | | 604| 23.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 23.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 23.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 23.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 23.2k]
| | | | ------------------
| | | | 608| 23.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 23.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 23.2k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 23.2k]
| | ------------------
------------------
267| |
268| 23.2k| IGRAPH_FINALLY_CLEAN(11);
269| |
270| 23.2k| return IGRAPH_SUCCESS;
271| 23.2k|}
graphml.c:igraph_i_graphml_attribute_record_destroy:
208| 17.3k|static void igraph_i_graphml_attribute_record_destroy(igraph_i_graphml_attribute_record_t* rec) {
209| 17.3k| if (!rec->record_disowned) {
------------------
| Branch (209:9): [True: 4.22k, False: 13.1k]
------------------
210| 4.22k| igraph_attribute_record_destroy(&rec->record);
211| 4.22k| }
212| |
213| 17.3k| if (rec->id != NULL) {
------------------
| Branch (213:9): [True: 17.1k, False: 229]
------------------
214| 17.1k| igraph_free(rec->id);
215| 17.1k| rec->id = NULL;
216| 17.1k| }
217| |
218| 17.3k| memset(rec, 0, sizeof(igraph_i_graphml_attribute_record_t));
219| 17.3k|}
graphml.c:igraph_i_graphml_parser_state_destroy:
273| 23.2k|static void igraph_i_graphml_parser_state_destroy(struct igraph_i_graphml_parser_state* state) {
274| 23.2k| igraph_trie_destroy(&state->node_trie);
275| 23.2k| igraph_strvector_destroy(&state->edgeids);
276| 23.2k| igraph_trie_destroy(&state->v_attr_ids);
277| 23.2k| igraph_trie_destroy(&state->e_attr_ids);
278| 23.2k| igraph_trie_destroy(&state->g_attr_ids);
279| 23.2k| igraph_vector_int_destroy(&state->edgelist);
280| 23.2k| igraph_vector_int_destroy(&state->prev_state_stack);
281| |
282| 23.2k| igraph_vector_ptr_destroy_all(&state->v_attrs);
283| 23.2k| igraph_vector_ptr_destroy_all(&state->e_attrs);
284| 23.2k| igraph_vector_ptr_destroy_all(&state->g_attrs);
285| |
286| 23.2k| igraph_vector_char_destroy(&state->data_char);
287| |
288| 23.2k| if (state->data_key) {
------------------
| Branch (288:9): [True: 3.58k, False: 19.6k]
------------------
289| 3.58k| xmlFree((void *) state->data_key);
290| 3.58k| state->data_key = NULL;
291| 3.58k| }
292| |
293| 23.2k| if (state->error_message) {
------------------
| Branch (293:9): [True: 16.5k, False: 6.61k]
------------------
294| | IGRAPH_FREE(state->error_message);
------------------
| | 36| 16.5k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
295| 16.5k| }
296| 23.2k|}
graphml.c:igraph_i_graphml_parser_state_set_error_from_varargs:
300| 570|) {
301| 570| const size_t max_error_message_length = 4096;
302| |
303| 570| state->successful = 0;
304| 570| state->st = ERROR;
305| |
306| 570| if (state->error_message == 0) {
------------------
| Branch (306:9): [True: 557, False: 13]
------------------
307| | /* ownership of state->error_message passed on immediately to
308| | * state so the state destructor is responsible for freeing it */
309| 557| state->error_message = IGRAPH_CALLOC(max_error_message_length, char);
------------------
| | 33| 557|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.11k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 557, Folded]
| | | | ------------------
| | ------------------
------------------
310| 557| }
311| |
312| | /* we need to guard against state->error_message == 0, which may happen
313| | * if the memory allocation for the error message itself failed */
314| 570| if (state->error_message != 0) {
------------------
| Branch (314:9): [True: 570, False: 0]
------------------
315| 570| vsnprintf(state->error_message, max_error_message_length, msg, args);
316| 570| }
317| 570|}
graphml.c:igraph_i_libxml_structured_error_handler:
1429| 236k|static void igraph_i_libxml_structured_error_handler(void* ctx, const xmlError *error) {
1430| 236k|#endif
1431| 236k| struct igraph_i_graphml_parser_state* state = (struct igraph_i_graphml_parser_state*) ctx;
1432| 236k| igraph_i_graphml_parser_state_set_error_from_xmlerror(state, error);
1433| 236k|}
graphml.c:igraph_i_graphml_parser_state_set_error_from_xmlerror:
321| 236k|) {
322| 236k| const size_t max_error_message_length = 4096;
323| |
324| 236k| state->successful = 0;
325| 236k| state->st = ERROR;
326| |
327| 236k| if (state->error_message == 0) {
------------------
| Branch (327:9): [True: 16.0k, False: 220k]
------------------
328| | /* ownership of state->error_message passed on immediately to
329| | * state so the state destructor is responsible for freeing it */
330| 16.0k| state->error_message = IGRAPH_CALLOC(max_error_message_length, char);
------------------
| | 33| 16.0k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 32.0k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 16.0k, Folded]
| | | | ------------------
| | ------------------
------------------
331| 16.0k| }
332| |
333| | /* we need to guard against state->error_message == 0, which may happen
334| | * if the memory allocation for the error message itself failed */
335| 236k| if (state->error_message != 0) {
------------------
| Branch (335:9): [True: 236k, False: 0]
------------------
336| 236k| snprintf(state->error_message, max_error_message_length, "Line %d: %s",
337| 236k| error->line, error->message);
338| 236k| }
339| 236k|}
graphml.c:igraph_i_graphml_sax_handler_get_entity:
351| 19.7k| const xmlChar* name) {
352| 19.7k| xmlEntityPtr predef = xmlGetPredefinedEntity(name);
353| 19.7k| const char* entityName;
354| |
355| 19.7k| IGRAPH_UNUSED(state0);
------------------
| | 30| 19.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
356| 19.7k| if (predef != NULL) {
------------------
| Branch (356:9): [True: 5.07k, False: 14.6k]
------------------
357| 5.07k| return predef;
358| 5.07k| }
359| |
360| 14.6k| entityName = fromXmlChar(name);
------------------
| | 76| 14.6k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
361| 14.6k| IGRAPH_WARNINGF("Unknown XML entity found: '%s'.", entityName);
------------------
| | 777| 14.6k| do { \
| | 778| 14.6k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 14.6k| __VA_ARGS__); \
| | 780| 14.6k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 14.6k]
| | ------------------
------------------
362| |
363| 14.6k| return &blankEntity;
364| 19.7k|}
graphml.c:igraph_i_graphml_sax_handler_start_document:
377| 22.4k|static void igraph_i_graphml_sax_handler_start_document(void *state0) {
378| 22.4k| struct igraph_i_graphml_parser_state *state =
379| 22.4k| (struct igraph_i_graphml_parser_state*)state0;
380| |
381| 22.4k| state->st = START;
382| 22.4k| state->successful = 1;
383| 22.4k| state->edges_directed = 0;
384| | state->data_key = NULL;
385| 22.4k| state->unknown_depth = 0;
386| 22.4k| state->ignore_namespaces = 0;
387| 22.4k|}
graphml.c:igraph_i_graphml_sax_handler_chars:
1298| 40.9M|static void igraph_i_graphml_sax_handler_chars(void* state0, const xmlChar* ch, int len) {
1299| 40.9M| struct igraph_i_graphml_parser_state *state =
1300| 40.9M| (struct igraph_i_graphml_parser_state*)state0;
1301| 40.9M| igraph_error_t result = IGRAPH_SUCCESS;
1302| |
1303| 40.9M| if (!state->successful) {
------------------
| Branch (1303:9): [True: 9.86k, False: 40.9M]
------------------
1304| 9.86k| return;
1305| 9.86k| }
1306| |
1307| 40.9M| switch (state->st) {
1308| 2.64k| case INSIDE_KEY:
------------------
| Branch (1308:5): [True: 2.64k, False: 40.8M]
------------------
1309| 2.64k| break;
1310| |
1311| 39.1M| case INSIDE_DATA:
------------------
| Branch (1311:5): [True: 39.1M, False: 1.75M]
------------------
1312| 39.1M| case INSIDE_DEFAULT:
------------------
| Branch (1312:5): [True: 10.3k, False: 40.8M]
------------------
1313| 39.1M| result = igraph_i_graphml_append_to_data_char(state, ch, len);
1314| 39.1M| break;
1315| |
1316| 1.74M| default:
------------------
| Branch (1316:5): [True: 1.74M, False: 39.1M]
------------------
1317| | /* just ignore it */
1318| 1.74M| break;
1319| 40.9M| }
1320| |
1321| 40.9M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1321:9): [True: 0, False: 40.9M]
------------------
1322| 0| RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file.", result);
------------------
| | 85| 0| do { \
| | 86| 0| GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code); \
| | ------------------
| | | | 79| 0| do { \
| | | | 80| 0| if (state->successful) { \
| | | | ------------------
| | | | | Branch (80:13): [True: 0, False: 0]
| | | | ------------------
| | | | 81| 0| igraph_i_graphml_sax_handler_error(state, msg); \
| | | | 82| 0| } \
| | | | 83| 0| } while (0)
| | | | ------------------
| | | | | Branch (83:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 87| 0| return; \
| | 88| 0| } while (0)
| | ------------------
| | | Branch (88:14): [Folded, False: 0]
| | ------------------
------------------
1323| 0| }
1324| 40.9M|}
graphml.c:igraph_i_graphml_append_to_data_char:
780| 39.1M|) {
781| 39.1M| const igraph_vector_char_t data_vec =
782| 39.1M| igraph_vector_char_view((char *) data, len);
783| |
784| 39.1M| if (!state->successful) {
------------------
| Branch (784:9): [True: 0, False: 39.1M]
------------------
785| 0| return IGRAPH_SUCCESS;
786| 0| }
787| |
788| 39.1M| IGRAPH_STATIC_ASSERT(sizeof(char) == sizeof(xmlChar));
------------------
| | 68| 39.1M|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
789| 39.1M| IGRAPH_CHECK(igraph_vector_char_append(
------------------
| | 656| 39.1M| do { \
| | 657| 39.1M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 39.1M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 39.1M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39.1M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 39.1M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 39.1M]
| | ------------------
------------------
790| 39.1M| &state->data_char,
791| 39.1M| &data_vec
792| 39.1M| ));
793| |
794| 39.1M| return IGRAPH_SUCCESS;
795| 39.1M|}
graphml.c:igraph_i_graphml_sax_handler_error:
341| 570|static void igraph_i_graphml_sax_handler_error(void *state0, const char* msg, ...) {
342| 570| struct igraph_i_graphml_parser_state *state =
343| 570| (struct igraph_i_graphml_parser_state*)state0;
344| 570| va_list args;
345| 570| va_start(args, msg);
346| 570| igraph_i_graphml_parser_state_set_error_from_varargs(state, msg, args);
347| | va_end(args);
348| 570|}
graphml.c:igraph_i_graphml_sax_handler_start_element_ns:
1198| 3.76M| int nb_attributes, int nb_defaulted, const xmlChar** attributes) {
1199| 3.76M| struct igraph_i_graphml_parser_state *state =
1200| 3.76M| (struct igraph_i_graphml_parser_state*)state0;
1201| 3.76M| igraph_error_t result;
1202| |
1203| 3.76M| if (!state->successful) {
------------------
| Branch (1203:9): [True: 56.4k, False: 3.71M]
------------------
1204| 56.4k| return;
1205| 56.4k| }
1206| |
1207| 3.71M| result = igraph_i_graphml_sax_handler_start_element_ns_inner(
1208| 3.71M| state, localname, prefix, uri, nb_namespaces, namespaces,
1209| 3.71M| nb_attributes, nb_defaulted, attributes
1210| 3.71M| );
1211| |
1212| 3.71M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1212:9): [True: 473, False: 3.71M]
------------------
1213| 473| RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file.", result);
------------------
| | 85| 473| do { \
| | 86| 473| GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code); \
| | ------------------
| | | | 79| 473| do { \
| | | | 80| 473| if (state->successful) { \
| | | | ------------------
| | | | | Branch (80:13): [True: 473, False: 0]
| | | | ------------------
| | | | 81| 473| igraph_i_graphml_sax_handler_error(state, msg); \
| | | | 82| 473| } \
| | | | 83| 473| } while (0)
| | | | ------------------
| | | | | Branch (83:14): [Folded, False: 473]
| | | | ------------------
| | ------------------
| | 87| 473| return; \
| | 88| 473| } while (0)
| | ------------------
| | | Branch (88:14): [Folded, False: 0]
| | ------------------
------------------
1214| 473| }
1215| 3.71M|}
graphml.c:igraph_i_graphml_sax_handler_start_element_ns_inner:
946| 3.71M| int nb_attributes, int nb_defaulted, const xmlChar** attributes) {
947| 3.71M| xmlChar** it;
948| 3.71M| xmlChar* attr_value = 0;
949| 3.71M| igraph_int_t id1, id2;
950| 3.71M| int i;
951| 3.71M| igraph_bool_t tag_is_unknown = false;
952| |
953| 3.71M| IGRAPH_UNUSED(prefix);
------------------
| | 30| 3.71M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
954| 3.71M| IGRAPH_UNUSED(nb_namespaces);
------------------
| | 30| 3.71M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
955| 3.71M| IGRAPH_UNUSED(namespaces);
------------------
| | 30| 3.71M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
956| 3.71M| IGRAPH_UNUSED(nb_defaulted);
------------------
| | 30| 3.71M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
957| |
958| 3.71M| if (uri) {
------------------
| Branch (958:9): [True: 997k, False: 2.71M]
------------------
959| 997k| if (!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), uri)) {
------------------
| | 75| 997k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 997k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (959:13): [True: 5.97k, False: 991k]
------------------
960| | /* Tag is in a different namespace, so treat it as an unknown start
961| | * tag irrespectively of our state */
962| 5.97k| tag_is_unknown = 1;
963| 5.97k| }
964| 2.71M| } else {
965| | /* No namespace URI. If we are in lenient mode, accept it and proceed
966| | * as if we are in the GraphML namespace to handle lots of naive
967| | * non-namespace-aware GraphML files floating out there. If we are not
968| | * in lenient mode _but_ we are in the START state, accept it as well
969| | * and see whether the root tag is (in which case we will
970| | * enter lenient mode). Otherwise, reject the tag */
971| 2.71M| if (!state->ignore_namespaces && state->st != START) {
------------------
| Branch (971:13): [True: 2.43M, False: 285k]
| Branch (971:42): [True: 2.42M, False: 6.67k]
------------------
972| 2.42M| tag_is_unknown = 1;
973| 2.42M| }
974| 2.71M| }
975| |
976| 3.71M| if (tag_is_unknown) {
------------------
| Branch (976:9): [True: 2.43M, False: 1.28M]
------------------
977| 2.43M| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 2.43M| do { \
| | 657| 2.43M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.43M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.43M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.43M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.43M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.43M]
| | ------------------
------------------
978| 2.43M| goto exit;
979| 2.43M| }
980| |
981| 1.28M| switch (state->st) {
982| 10.4k| case START:
------------------
| Branch (982:5): [True: 10.4k, False: 1.27M]
------------------
983| | /* If we are in the START state and received a graphml tag,
984| | * change to INSIDE_GRAPHML state. Otherwise, change to UNKNOWN. */
985| 10.4k| if (xmlStrEqual(localname, toXmlChar("graphml"))) {
------------------
| | 75| 10.4k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 10.4k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (985:13): [True: 8.10k, False: 2.30k]
------------------
986| 8.10k| if (uri == 0) {
------------------
| Branch (986:17): [True: 4.36k, False: 3.73k]
------------------
987| 4.36k| state->ignore_namespaces = 1;
988| 4.36k| }
989| 8.10k| state->st = INSIDE_GRAPHML;
990| 8.10k| } else {
991| 2.30k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 2.30k| do { \
| | 657| 2.30k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.30k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.30k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.30k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.30k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.30k]
| | ------------------
------------------
992| 2.30k| }
993| 10.4k| break;
994| |
995| 27.0k| case INSIDE_GRAPHML:
------------------
| Branch (995:5): [True: 27.0k, False: 1.25M]
------------------
996| | /* If we are in the INSIDE_GRAPHML state and received a graph tag,
997| | * change to INSIDE_GRAPH state if the state->index counter reached
998| | * zero (this is to handle multiple graphs in the same file).
999| | * Otherwise, change to UNKNOWN. */
1000| 27.0k| if (xmlStrEqual(localname, toXmlChar("graph"))) {
------------------
| | 75| 27.0k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 27.0k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1000:13): [True: 8.73k, False: 18.3k]
------------------
1001| 8.73k| if (state->index == 0) {
------------------
| Branch (1001:17): [True: 7.18k, False: 1.54k]
------------------
1002| 7.18k| state->st = INSIDE_GRAPH;
1003| 15.8k| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1003:57): [True: 8.62k, False: 7.18k]
------------------
1004| 8.62k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 8.62k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1004:25): [True: 20, False: 8.60k]
------------------
1005| 20| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 20|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 20|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 20|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1005:25): [True: 10, False: 10]
------------------
1006| | /* Attribute is from a different namespace, so skip it */
1007| 10| continue;
1008| 10| }
1009| 8.61k| if (xmlStrEqual(*it, toXmlChar("edgedefault"))) {
------------------
| | 75| 8.61k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 8.61k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1009:25): [True: 3.61k, False: 4.99k]
------------------
1010| 3.61k| if (xmlAttrValueEqual(it, "directed")) {
------------------
| Branch (1010:29): [True: 283, False: 3.33k]
------------------
1011| 283| state->edges_directed = 1;
1012| 3.33k| } else if (xmlAttrValueEqual(it, "undirected")) {
------------------
| Branch (1012:36): [True: 3.21k, False: 114]
------------------
1013| 3.21k| state->edges_directed = 0;
1014| 3.21k| }
1015| 3.61k| }
1016| 8.61k| }
1017| 7.18k| }
1018| 8.73k| state->index--;
1019| 18.3k| } else if (xmlStrEqual(localname, toXmlChar("key"))) {
------------------
| | 75| 18.3k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 18.3k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1019:20): [True: 17.3k, False: 950]
------------------
1020| 17.3k| IGRAPH_CHECK(
------------------
| | 656| 17.3k| do { \
| | 657| 17.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 392, False: 16.9k]
| | | | ------------------
| | ------------------
| | 659| 392| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 392| do { \
| | | | 427| 392| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 392| return igraph_errno ; \
| | | | 429| 392| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 392| } \
| | 661| 17.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.9k]
| | ------------------
------------------
1021| 17.3k| igraph_i_graphml_add_attribute_key(
1022| 17.3k| &state->current_attr_record,
1023| 17.3k| attributes, nb_attributes, state
1024| 17.3k| )
1025| 17.3k| );
1026| | /* NULL is okay here for state->current_attr_record -- we should have
1027| | * triggered an error in the parser already if we returned NULL, and
1028| | * the rest of the code is prepared to handle NULLs */
1029| 16.9k| state->st = INSIDE_KEY;
1030| 16.9k| } else {
1031| 950| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 950| do { \
| | 657| 950| igraph_error_t igraph_i_ret = (expr); \
| | 658| 950| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 950| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 950]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 950| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 950]
| | ------------------
------------------
1032| 950| }
1033| 26.6k| break;
1034| |
1035| 26.6k| case INSIDE_KEY:
------------------
| Branch (1035:5): [True: 4.07k, False: 1.27M]
------------------
1036| | /* If we are in the INSIDE_KEY state and we are not skipping the current
1037| | * attribute, check for default tag */
1038| 4.07k| if (state->current_attr_record != NULL && xmlStrEqual(localname, toXmlChar("default"))) {
------------------
| | 75| 3.72k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 3.72k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1038:13): [True: 3.72k, False: 345]
| Branch (1038:51): [True: 3.48k, False: 239]
------------------
1039| 3.48k| state->st = INSIDE_DEFAULT;
1040| 3.48k| } else {
1041| 584| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 584| do { \
| | 657| 584| igraph_error_t igraph_i_ret = (expr); \
| | 658| 584| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 584| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 584]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 584| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 584]
| | ------------------
------------------
1042| 584| }
1043| 4.07k| break;
1044| |
1045| 4.07k| case INSIDE_DEFAULT:
------------------
| Branch (1045:5): [True: 443, False: 1.28M]
------------------
1046| | /* If we are in the INSIDE_DEFAULT state, every further tag will be unknown */
1047| 443| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 443| do { \
| | 657| 443| igraph_error_t igraph_i_ret = (expr); \
| | 658| 443| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 443| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 443]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 443| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 443]
| | ------------------
------------------
1048| 443| break;
1049| |
1050| 739k| case INSIDE_GRAPH:
------------------
| Branch (1050:5): [True: 739k, False: 543k]
------------------
1051| | /* If we are in the INSIDE_GRAPH state, check for node and edge tags */
1052| 739k| if (xmlStrEqual(localname, toXmlChar("edge"))) {
------------------
| | 75| 739k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 739k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1052:13): [True: 696k, False: 43.0k]
------------------
1053| 696k| id1 = -1; id2 = -1;
1054| 2.23M| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1054:53): [True: 1.53M, False: 696k]
------------------
1055| 1.53M| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 1.53M|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1055:21): [True: 76, False: 1.53M]
------------------
1056| 76| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 76|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 76|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 76|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1056:21): [True: 66, False: 10]
------------------
1057| | /* Attribute is from a different namespace, so skip it */
1058| 66| continue;
1059| 66| }
1060| 1.53M| if (xmlStrEqual(*it, toXmlChar("source"))) {
------------------
| | 75| 1.53M|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 1.53M|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1060:21): [True: 696k, False: 838k]
------------------
1061| 696k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 696k|#define XML_ATTR_VALUE(it) it[3], (int)(it[4] - it[3]) /* for use in strnxxx()-style functions that take a char * and a length */
------------------
1062| 696k| if (attr_value == 0) {
------------------
| Branch (1062:25): [True: 0, False: 696k]
------------------
1063| 0| IGRAPH_ERROR("Cannot copy value of edge source attribute.", IGRAPH_ENOMEM);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1064| 0| }
1065| 696k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 696k| do { \
| | 604| 696k| /* the following branch makes the compiler check the compatibility of \
| | 605| 696k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 696k| * incorrect destructor function with the pointer */ \
| | 607| 696k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 696k]
| | ------------------
| | 608| 696k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 696k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 696k]
| | ------------------
------------------
1066| |
1067| 696k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id1));
------------------
| | 656| 696k| do { \
| | 657| 696k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 696k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 696k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 696k]
| | | | ------------------
| | ------------------
| | 659| 1| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 1| do { \
| | | | 427| 1| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 1| return igraph_errno ; \
| | | | 429| 1| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 1| } \
| | 661| 696k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 696k]
| | ------------------
------------------
1068| |
1069| 696k| xmlFree(attr_value); attr_value = NULL;
1070| 696k| IGRAPH_FINALLY_CLEAN(1);
1071| 838k| } else if (xmlStrEqual(*it, toXmlChar("target"))) {
------------------
| | 75| 838k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 838k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1071:28): [True: 696k, False: 141k]
------------------
1072| 696k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 696k|#define XML_ATTR_VALUE(it) it[3], (int)(it[4] - it[3]) /* for use in strnxxx()-style functions that take a char * and a length */
------------------
1073| 696k| if (attr_value == 0) {
------------------
| Branch (1073:25): [True: 0, False: 696k]
------------------
1074| 0| IGRAPH_ERROR("Cannot copy value of edge target attribute.", IGRAPH_ENOMEM);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1075| 0| }
1076| 696k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 696k| do { \
| | 604| 696k| /* the following branch makes the compiler check the compatibility of \
| | 605| 696k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 696k| * incorrect destructor function with the pointer */ \
| | 607| 696k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 696k]
| | ------------------
| | 608| 696k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 696k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 696k]
| | ------------------
------------------
1077| |
1078| 696k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id2));
------------------
| | 656| 696k| do { \
| | 657| 696k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 696k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 696k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 696k]
| | | | ------------------
| | ------------------
| | 659| 1| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 1| do { \
| | | | 427| 1| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 1| return igraph_errno ; \
| | | | 429| 1| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 1| } \
| | 661| 696k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 696k]
| | ------------------
------------------
1079| |
1080| 696k| xmlFree(attr_value); attr_value = NULL;
1081| 696k| IGRAPH_FINALLY_CLEAN(1);
1082| 696k| } else if (xmlStrEqual(*it, toXmlChar("id"))) {
------------------
| | 75| 141k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 141k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1082:28): [True: 135k, False: 5.95k]
------------------
1083| 135k| igraph_int_t edges = igraph_vector_int_size(&state->edgelist) / 2 + 1;
1084| 135k| igraph_int_t origsize = igraph_strvector_size(&state->edgeids);
1085| |
1086| 135k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 135k|#define XML_ATTR_VALUE(it) it[3], (int)(it[4] - it[3]) /* for use in strnxxx()-style functions that take a char * and a length */
------------------
1087| 135k| if (attr_value == 0) {
------------------
| Branch (1087:25): [True: 0, False: 135k]
------------------
1088| 0| IGRAPH_ERROR("Cannot copy value of edge ID attribute.", IGRAPH_ENOMEM);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1089| 0| }
1090| 135k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 135k| do { \
| | 604| 135k| /* the following branch makes the compiler check the compatibility of \
| | 605| 135k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 135k| * incorrect destructor function with the pointer */ \
| | 607| 135k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 135k]
| | ------------------
| | 608| 135k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 135k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 135k]
| | ------------------
------------------
1091| |
1092| 135k| IGRAPH_CHECK(igraph_strvector_resize(&state->edgeids, edges));
------------------
| | 656| 135k| do { \
| | 657| 135k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 135k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 135k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 135k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 135k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 135k]
| | ------------------
------------------
1093| |
1094| 177k| for (; origsize < edges - 1; origsize++) {
------------------
| Branch (1094:28): [True: 41.1k, False: 135k]
------------------
1095| 41.1k| IGRAPH_CHECK(igraph_strvector_set(&state->edgeids, origsize, ""));
------------------
| | 656| 41.1k| do { \
| | 657| 41.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 41.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 41.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 41.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 41.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 41.1k]
| | ------------------
------------------
1096| 41.1k| }
1097| |
1098| 135k| IGRAPH_CHECK(igraph_strvector_set(&state->edgeids, edges - 1, fromXmlChar(attr_value)));
------------------
| | 656| 135k| do { \
| | 657| 135k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 135k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 135k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 135k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 135k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 135k]
| | ------------------
------------------
1099| |
1100| 135k| xmlFree(attr_value); attr_value = NULL;
1101| 135k| IGRAPH_FINALLY_CLEAN(1);
1102| 135k| }
1103| 1.53M| }
1104| 696k| if (id1 >= 0 && id2 >= 0) {
------------------
| Branch (1104:17): [True: 696k, False: 45]
| Branch (1104:29): [True: 696k, False: 14]
------------------
1105| 696k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->edgelist, id1));
------------------
| | 656| 696k| do { \
| | 657| 696k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 696k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 696k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 696k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 696k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 696k]
| | ------------------
------------------
1106| 696k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->edgelist, id2));
------------------
| | 656| 696k| do { \
| | 657| 696k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 696k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 696k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 696k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 696k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 696k]
| | ------------------
------------------
1107| 696k| } else {
1108| 59| IGRAPH_ERROR("Edge with missing source or target encountered.", IGRAPH_PARSEERROR);
------------------
| | 426| 59| do { \
| | 427| 59| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 59| return igraph_errno ; \
| | 429| 59| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1109| 59| }
1110| 696k| state->st = INSIDE_EDGE;
1111| 696k| } else if (xmlStrEqual(localname, toXmlChar("node"))) {
------------------
| | 75| 43.0k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 43.0k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1111:20): [True: 34.2k, False: 8.74k]
------------------
1112| 34.2k| id1 = -1;
1113| 34.9k| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1113:53): [True: 34.9k, False: 18]
------------------
1114| 34.9k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 34.9k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1114:21): [True: 208, False: 34.7k]
------------------
1115| 208| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 208|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 208|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 208|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1115:21): [True: 198, False: 10]
------------------
1116| | /* Attribute is from a different namespace, so skip it */
1117| 198| continue;
1118| 198| }
1119| 34.7k| if (xmlStrEqual(XML_ATTR_LOCALNAME(it), toXmlChar("id"))) {
------------------
| | 495| 34.7k|#define XML_ATTR_LOCALNAME(it) it[0]
------------------
if (xmlStrEqual(XML_ATTR_LOCALNAME(it), toXmlChar("id"))) {
------------------
| | 75| 34.7k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 34.7k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1119:21): [True: 34.2k, False: 513]
------------------
1120| 34.2k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 34.2k|#define XML_ATTR_VALUE(it) it[3], (int)(it[4] - it[3]) /* for use in strnxxx()-style functions that take a char * and a length */
------------------
1121| 34.2k| if (attr_value == 0) {
------------------
| Branch (1121:25): [True: 0, False: 34.2k]
------------------
1122| 0| IGRAPH_ERROR("Cannot copy value of node ID attribute.", IGRAPH_ENOMEM);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1123| 0| }
1124| 34.2k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 34.2k| do { \
| | 604| 34.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 34.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 34.2k| * incorrect destructor function with the pointer */ \
| | 607| 34.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 34.2k]
| | ------------------
| | 608| 34.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 34.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 34.2k]
| | ------------------
------------------
1125| |
1126| 34.2k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id1));
------------------
| | 656| 34.2k| do { \
| | 657| 34.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 34.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 34.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 2, False: 34.2k]
| | | | ------------------
| | ------------------
| | 659| 2| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 2| do { \
| | | | 427| 2| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 2| return igraph_errno ; \
| | | | 429| 2| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 2| } \
| | 661| 34.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 34.2k]
| | ------------------
------------------
1127| |
1128| 34.2k| xmlFree(attr_value); attr_value = NULL;
1129| 34.2k| IGRAPH_FINALLY_CLEAN(1);
1130| 34.2k| break;
1131| 34.2k| }
1132| 34.7k| }
1133| 34.2k| if (id1 >= 0) {
------------------
| Branch (1133:17): [True: 34.2k, False: 18]
------------------
1134| 34.2k| state->act_node = id1;
1135| 34.2k| } else {
1136| 18| state->act_node = -1;
1137| 18| IGRAPH_ERROR("Node with missing ID encountered.", IGRAPH_PARSEERROR);
------------------
| | 426| 18| do { \
| | 427| 18| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 18| return igraph_errno ; \
| | 429| 18| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1138| 18| }
1139| 34.2k| state->st = INSIDE_NODE;
1140| 34.2k| } else if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 8.74k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 8.74k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1140:20): [True: 3.53k, False: 5.20k]
------------------
1141| 3.53k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 656| 3.53k| do { \
| | 657| 3.53k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.53k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.53k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.53k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.53k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.53k]
| | ------------------
------------------
1142| 3.53k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_GRAPH
1143| 3.53k| ));
1144| 3.53k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 3.53k| do { \
| | 657| 3.53k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.53k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.53k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.53k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.53k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.53k]
| | ------------------
------------------
1145| 3.53k| state->st = INSIDE_DATA;
1146| 5.20k| } else {
1147| 5.20k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 5.20k| do { \
| | 657| 5.20k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.20k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.20k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.20k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.20k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.20k]
| | ------------------
------------------
1148| 5.20k| }
1149| 739k| break;
1150| |
1151| 739k| case INSIDE_NODE:
------------------
| Branch (1151:5): [True: 51.8k, False: 1.23M]
------------------
1152| 51.8k| if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 51.8k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 51.8k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1152:13): [True: 51.6k, False: 224]
------------------
1153| 51.6k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 656| 51.6k| do { \
| | 657| 51.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 51.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.6k]
| | ------------------
------------------
1154| 51.6k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_VERTEX
1155| 51.6k| ));
1156| 51.6k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 51.6k| do { \
| | 657| 51.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 51.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.6k]
| | ------------------
------------------
1157| 51.6k| state->st = INSIDE_DATA;
1158| 51.6k| } else {
1159| 224| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 224| do { \
| | 657| 224| igraph_error_t igraph_i_ret = (expr); \
| | 658| 224| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 224| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 224]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 224| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 224]
| | ------------------
------------------
1160| 224| }
1161| 51.8k| break;
1162| |
1163| 363k| case INSIDE_EDGE:
------------------
| Branch (1163:5): [True: 363k, False: 919k]
------------------
1164| 363k| if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 363k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 363k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1164:13): [True: 363k, False: 500]
------------------
1165| 363k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 656| 363k| do { \
| | 657| 363k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 363k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 363k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 363k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 363k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 363k]
| | ------------------
------------------
1166| 363k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_EDGE
1167| 363k| ));
1168| 363k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 363k| do { \
| | 657| 363k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 363k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 363k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 363k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 363k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 363k]
| | ------------------
------------------
1169| 363k| state->st = INSIDE_DATA;
1170| 363k| } else {
1171| 500| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 500| do { \
| | 657| 500| igraph_error_t igraph_i_ret = (expr); \
| | 658| 500| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 500| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 500]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 500| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 500]
| | ------------------
------------------
1172| 500| }
1173| 363k| break;
1174| |
1175| 363k| case INSIDE_DATA:
------------------
| Branch (1175:5): [True: 291, False: 1.28M]
------------------
1176| | /* We do not expect any new tags within a tag */
1177| 291| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 291| do { \
| | 657| 291| igraph_error_t igraph_i_ret = (expr); \
| | 658| 291| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 291| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 291]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 291| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 291]
| | ------------------
------------------
1178| 291| break;
1179| |
1180| 84.8k| case UNKNOWN:
------------------
| Branch (1180:5): [True: 84.8k, False: 1.19M]
------------------
1181| 84.8k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 84.8k| do { \
| | 657| 84.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 84.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 84.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 84.8k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 84.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 84.8k]
| | ------------------
------------------
1182| 84.8k| break;
1183| |
1184| 84.8k| case FINISH:
------------------
| Branch (1184:5): [True: 761, False: 1.28M]
------------------
1185| 761| break;
1186| |
1187| 0| default:
------------------
| Branch (1187:5): [True: 0, False: 1.28M]
------------------
1188| 0| IGRAPH_FATALF("Unexpected GraphML reader state %d.", (int) state->st);
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
1189| 1.28M| }
1190| |
1191| 3.71M|exit:
1192| 3.71M| return IGRAPH_SUCCESS;
1193| 1.28M|}
graphml.c:igraph_i_graphml_handle_unknown_start_tag:
366| 2.52M|static igraph_error_t igraph_i_graphml_handle_unknown_start_tag(struct igraph_i_graphml_parser_state *state) {
367| 2.52M| if (state->st != UNKNOWN) {
------------------
| Branch (367:9): [True: 10.7k, False: 2.51M]
------------------
368| 10.7k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 10.7k| do { \
| | 657| 10.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10.7k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 10.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.7k]
| | ------------------
------------------
369| 10.7k| state->st = UNKNOWN;
370| 10.7k| state->unknown_depth = 1;
371| 2.51M| } else {
372| 2.51M| state->unknown_depth++;
373| 2.51M| }
374| 2.52M| return IGRAPH_SUCCESS;
375| 2.52M|}
graphml.c:xmlAttrValueEqual:
532| 80.4k|static igraph_bool_t xmlAttrValueEqual(xmlChar** attr, const char* expected) {
533| 80.4k| size_t expected_length = strlen(expected);
534| 80.4k| return (
535| 80.4k| expected_length == XML_ATTR_VALUE_LENGTH(attr) &&
------------------
| | 500| 160k|#define XML_ATTR_VALUE_LENGTH(it) (size_t)(it[4] - it[3])
------------------
| Branch (535:9): [True: 42.6k, False: 37.8k]
------------------
536| 42.6k| !xmlStrncmp(toXmlChar(expected), XML_ATTR_VALUE(attr))
------------------
| | 75| 42.6k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 42.6k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrncmp(toXmlChar(expected), XML_ATTR_VALUE(attr))
------------------
| | 501| 42.6k|#define XML_ATTR_VALUE(it) it[3], (int)(it[4] - it[3]) /* for use in strnxxx()-style functions that take a char * and a length */
------------------
| Branch (536:9): [True: 33.7k, False: 8.89k]
------------------
537| 80.4k| );
538| 80.4k|}
graphml.c:igraph_i_graphml_add_attribute_key:
544| 17.3k|) {
545| |
546| | /* This function must return in three possible ways:
547| | *
548| | * - a proper newly allocated attribute record is returned in 'record' and
549| | * the function returns IGRAPH_SUCCESS; the parser will process the attribute
550| | * - NULL is returned in 'record' and the function returns an igraph error
551| | * code; the parser will handle the error
552| | * - NULL is returned in 'record', but the function itself returns
553| | * IGRAPH_SUCCESS; the parser will skip the attribute
554| | *
555| | * The caller should be prepared to handle all three cases.
556| | */
557| |
558| 17.3k| xmlChar **it;
559| 17.3k| xmlChar *localname;
560| 17.3k| igraph_trie_t *trie = NULL;
561| 17.3k| igraph_vector_ptr_t *ptrvector = NULL;
562| 17.3k| igraph_int_t i, n;
563| 17.3k| igraph_int_t id;
564| 17.3k| igraph_i_graphml_attribute_record_t *rec = NULL;
565| 17.3k| char *attr_name;
566| 17.3k| igraph_attribute_type_t igraph_attr_type;
567| 17.3k| igraph_bool_t skip = false;
568| |
569| 17.3k| attr_name = NULL;
570| 17.3k| IGRAPH_FINALLY(safely_free_optional_string, &attr_name);
------------------
| | 603| 17.3k| do { \
| | 604| 17.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.3k| * incorrect destructor function with the pointer */ \
| | 607| 17.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.3k]
| | ------------------
| | 608| 17.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.3k]
| | ------------------
------------------
571| |
572| 17.3k| if (!state->successful) {
------------------
| Branch (572:9): [True: 0, False: 17.3k]
------------------
573| | /* Parser is already in an error state */
574| 0| goto exit;
575| 0| }
576| |
577| 17.3k| rec = IGRAPH_CALLOC(1, igraph_i_graphml_attribute_record_t);
------------------
| | 33| 17.3k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 34.7k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 17.3k, Folded]
| | | | ------------------
| | ------------------
------------------
578| 17.3k| IGRAPH_CHECK_OOM(rec, "Insufficient memory to allocate attribute record.");
------------------
| | 709| 17.3k| do { \
| | 710| 17.3k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 17.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.3k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 17.3k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 17.3k]
| | ------------------
------------------
579| 17.3k| IGRAPH_FINALLY(igraph_free, rec);
------------------
| | 603| 17.3k| do { \
| | 604| 17.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.3k| * incorrect destructor function with the pointer */ \
| | 607| 17.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.3k]
| | ------------------
| | 608| 17.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.3k]
| | ------------------
------------------
580| 17.3k| IGRAPH_FINALLY(igraph_i_graphml_attribute_record_destroy, rec);
------------------
| | 603| 17.3k| do { \
| | 604| 17.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.3k| * incorrect destructor function with the pointer */ \
| | 607| 17.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.3k]
| | ------------------
| | 608| 17.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.3k]
| | ------------------
------------------
581| 17.3k| memset(rec, 0, sizeof(igraph_i_graphml_attribute_record_t));
582| |
583| 17.3k| igraph_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
584| |
585| 78.7k| for (i = 0, it = (xmlChar**)attrs; i < nb_attrs; i++, it += 5) {
------------------
| Branch (585:40): [True: 61.6k, False: 17.0k]
------------------
586| 61.6k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 61.6k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (586:13): [True: 507, False: 61.1k]
------------------
587| 507| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 507|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 507|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 507|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (587:13): [True: 439, False: 68]
------------------
588| 439| continue;
589| 439| }
590| |
591| 61.1k| localname = XML_ATTR_LOCALNAME(it);
------------------
| | 495| 61.1k|#define XML_ATTR_LOCALNAME(it) it[0]
------------------
592| |
593| 61.1k| if (xmlStrEqual(localname, toXmlChar("id"))) {
------------------
| | 75| 61.1k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 61.1k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (593:13): [True: 17.1k, False: 44.0k]
------------------
594| 17.1k| safely_free_optional_string(&rec->id);
595| 17.1k| IGRAPH_CHECK(safely_convert_xml_attribute_to_string(it, &rec->id));
------------------
| | 656| 17.1k| do { \
| | 657| 17.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 17.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.1k]
| | ------------------
------------------
596| 44.0k| } else if (xmlStrEqual(localname, toXmlChar("attr.name"))) {
------------------
| | 75| 44.0k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 44.0k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (596:20): [True: 10.1k, False: 33.8k]
------------------
597| 10.1k| safely_free_optional_string(&attr_name);
598| 10.1k| IGRAPH_CHECK(safely_convert_xml_attribute_to_string(it, &attr_name));
------------------
| | 656| 10.1k| do { \
| | 657| 10.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10.1k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 10.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.1k]
| | ------------------
------------------
599| 33.8k| } else if (xmlStrEqual(localname, toXmlChar("attr.type"))) {
------------------
| | 75| 33.8k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 33.8k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (599:20): [True: 14.6k, False: 19.2k]
------------------
600| 14.6k| if (xmlAttrValueEqual(it, "boolean")) {
------------------
| Branch (600:17): [True: 2.57k, False: 12.0k]
------------------
601| 2.57k| igraph_attr_type = IGRAPH_ATTRIBUTE_BOOLEAN;
602| 2.57k| rec->type = I_GRAPHML_BOOLEAN;
603| 12.0k| } else if (xmlAttrValueEqual(it, "string")) {
------------------
| Branch (603:24): [True: 9.46k, False: 2.62k]
------------------
604| 9.46k| igraph_attr_type = IGRAPH_ATTRIBUTE_STRING;
605| 9.46k| rec->type = I_GRAPHML_STRING;
606| 9.46k| } else if (xmlAttrValueEqual(it, "float")) {
------------------
| Branch (606:24): [True: 209, False: 2.41k]
------------------
607| 209| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
608| 209| rec->type = I_GRAPHML_FLOAT;
609| 2.41k| } else if (xmlAttrValueEqual(it, "double")) {
------------------
| Branch (609:24): [True: 2.03k, False: 377]
------------------
610| 2.03k| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
611| 2.03k| rec->type = I_GRAPHML_DOUBLE;
612| 2.03k| } else if (xmlAttrValueEqual(it, "int")) {
------------------
| Branch (612:24): [True: 225, False: 152]
------------------
613| 225| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
614| 225| rec->type = I_GRAPHML_INTEGER;
615| 225| } else if (xmlAttrValueEqual(it, "long")) {
------------------
| Branch (615:24): [True: 70, False: 82]
------------------
616| 70| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
617| 70| rec->type = I_GRAPHML_LONG;
618| 82| } else {
619| 82| IGRAPH_ERRORF("Unknown attribute type '%.*s'.", IGRAPH_PARSEERROR,
------------------
| | 464| 82| do { \
| | 465| 82| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 82| igraph_errno, __VA_ARGS__) ; \
| | 467| 82| return igraph_errno; \
| | 468| 82| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
620| 82| XML_ATTR_VALUE_PF(it));
621| 82| }
622| 19.2k| } else if (xmlStrEqual(*it, toXmlChar("for"))) {
------------------
| | 75| 19.2k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 19.2k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (622:20): [True: 15.8k, False: 3.35k]
------------------
623| | /* graph, vertex or edge attribute? */
624| 15.8k| if (xmlAttrValueEqual(it, "graph")) {
------------------
| Branch (624:17): [True: 1.98k, False: 13.8k]
------------------
625| 1.98k| trie = &state->g_attr_ids;
626| 1.98k| ptrvector = &state->g_attrs;
627| 13.8k| } else if (xmlAttrValueEqual(it, "node")) {
------------------
| Branch (627:24): [True: 7.31k, False: 6.55k]
------------------
628| 7.31k| trie = &state->v_attr_ids;
629| 7.31k| ptrvector = &state->v_attrs;
630| 7.31k| } else if (xmlAttrValueEqual(it, "edge")) {
------------------
| Branch (630:24): [True: 5.05k, False: 1.49k]
------------------
631| 5.05k| trie = &state->e_attr_ids;
632| 5.05k| ptrvector = &state->e_attrs;
633| 5.05k| } else if (xmlAttrValueEqual(it, "graphml")) {
------------------
| Branch (633:24): [True: 194, False: 1.30k]
------------------
634| 194| igraph_i_report_unhandled_attribute_target("graphml", IGRAPH_FILE_BASENAME, __LINE__);
635| 194| skip = 1;
636| 1.30k| } else if (xmlAttrValueEqual(it, "hyperedge")) {
------------------
| Branch (636:24): [True: 68, False: 1.23k]
------------------
637| 68| igraph_i_report_unhandled_attribute_target("hyperedge", IGRAPH_FILE_BASENAME, __LINE__);
638| 68| skip = 1;
639| 1.23k| } else if (xmlAttrValueEqual(it, "port")) {
------------------
| Branch (639:24): [True: 668, False: 569]
------------------
640| 668| igraph_i_report_unhandled_attribute_target("port", IGRAPH_FILE_BASENAME, __LINE__);
641| 668| skip = 1;
642| 668| } else if (xmlAttrValueEqual(it, "endpoint")) {
------------------
| Branch (642:24): [True: 198, False: 371]
------------------
643| 198| igraph_i_report_unhandled_attribute_target("endpoint", IGRAPH_FILE_BASENAME, __LINE__);
644| 198| skip = 1;
645| 371| } else if (xmlAttrValueEqual(it, "all")) {
------------------
| Branch (645:24): [True: 181, False: 190]
------------------
646| | /* TODO: we should handle this */
647| 181| igraph_i_report_unhandled_attribute_target("all", IGRAPH_FILE_BASENAME, __LINE__);
648| 181| skip = 1;
649| 190| } else {
650| 190| IGRAPH_ERRORF("Unknown value '%.*s' in the 'for' attribute of a tag.", IGRAPH_PARSEERROR,
------------------
| | 464| 190| do { \
| | 465| 190| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 190| igraph_errno, __VA_ARGS__) ; \
| | 467| 190| return igraph_errno; \
| | 468| 190| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
651| 190| XML_ATTR_VALUE_PF(it));
652| 190| }
653| 15.8k| }
654| 61.1k| }
655| |
656| | /* throw an error if there is no ID; this is a clear violation of the GraphML DTD */
657| 17.0k| if (rec->id == NULL) {
------------------
| Branch (657:9): [True: 69, False: 17.0k]
------------------
658| 69| IGRAPH_ERROR("Found tag with no 'id' attribute.", IGRAPH_PARSEERROR);
------------------
| | 426| 69| do { \
| | 427| 69| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 69| return igraph_errno ; \
| | 429| 69| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
659| 69| }
660| |
661| | /* throw an error if the ID is an empty string; this is also a clear violation of the GraphML DTD */
662| 17.0k| if (*(rec->id) == '\0') {
------------------
| Branch (662:9): [True: 45, False: 16.9k]
------------------
663| 45| IGRAPH_ERROR("Found tag with an empty 'id' attribute.", IGRAPH_PARSEERROR);
------------------
| | 426| 45| do { \
| | 427| 45| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 45| return igraph_errno ; \
| | 429| 45| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
664| 45| }
665| |
666| | /* in case of a missing attr.name attribute, use the id as the attribute name */
667| 16.9k| if (attr_name == NULL) {
------------------
| Branch (667:9): [True: 6.83k, False: 10.1k]
------------------
668| | /* Allocation here is protected by safely_free_optional_string(&attr_name),
669| | * which is already in the finally stack */
670| 6.83k| attr_name = strdup(rec->id);
671| 6.83k| IGRAPH_CHECK_OOM(attr_name, "Cannot duplicate attribute ID as name.");
------------------
| | 709| 6.83k| do { \
| | 710| 6.83k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 6.83k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.83k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 6.83k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 6.83k]
| | ------------------
------------------
672| 6.83k| }
673| |
674| | /* if the attribute type is missing, ignore the attribute with a warning */
675| 16.9k| if (!skip && rec->type == I_GRAPHML_UNKNOWN_TYPE) {
------------------
| Branch (675:9): [True: 15.6k, False: 1.29k]
| Branch (675:18): [True: 0, False: 15.6k]
------------------
676| 0| IGRAPH_WARNINGF("Ignoring because of a missing 'attr.type' attribute.", rec->id);
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
677| 0| skip = 1;
678| 0| }
679| |
680| | /* if the value of the 'for' attribute was missing, ignore the attribute with a warning */
681| 16.9k| if (!skip && trie == 0) {
------------------
| Branch (681:9): [True: 15.6k, False: 1.29k]
| Branch (681:18): [True: 1.42k, False: 14.2k]
------------------
682| 1.42k| IGRAPH_WARNINGF("Ignoring because of a missing 'for' attribute.", rec->id);
------------------
| | 777| 1.42k| do { \
| | 778| 1.42k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 1.42k| __VA_ARGS__); \
| | 780| 1.42k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 1.42k]
| | ------------------
------------------
683| 1.42k| skip = 1;
684| 1.42k| }
685| |
686| | /* If attribute is skipped, proceed according to the type of the associated graph element. */
687| 16.9k| if (skip) {
------------------
| Branch (687:9): [True: 2.71k, False: 14.2k]
------------------
688| 2.71k| if (trie == 0) {
------------------
| Branch (688:13): [True: 2.71k, False: 0]
------------------
689| | /* Attribute was skipped because it is not for a node, edge or the graph.
690| | * Free everything and return. */
691| 2.71k| if (rec) {
------------------
| Branch (691:17): [True: 2.71k, False: 0]
------------------
692| 2.71k| igraph_i_graphml_attribute_record_destroy(rec);
693| 2.71k| IGRAPH_FREE(rec);
------------------
| | 36| 2.71k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
694| 2.71k| }
695| 2.71k| IGRAPH_FINALLY_CLEAN(2);
696| 2.71k| goto exit;
697| 2.71k| } else {
698| | /* If the skipped attribute was for a supported graph element, we add it
699| | * as "UNSPECIFIED" so that we can avoid reporting "unknown attribute" warnings
700| | * later. */
701| 0| igraph_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
702| 0| }
703| 2.71k| }
704| |
705| | /* check if we have already seen this ID */
706| 14.2k| IGRAPH_CHECK(igraph_trie_check(trie, rec->id, &id));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
707| 14.2k| if (id >= 0) {
------------------
| Branch (707:9): [True: 5, False: 14.2k]
------------------
708| 5| IGRAPH_ERRORF("Duplicate attribute ID found: '%s'.", IGRAPH_PARSEERROR, rec->id);
------------------
| | 464| 5| do { \
| | 465| 5| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 5| igraph_errno, __VA_ARGS__) ; \
| | 467| 5| return igraph_errno; \
| | 468| 5| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
709| 5| }
710| |
711| | /* check if we have already seen this attribute name */
712| 14.2k| n = igraph_vector_ptr_size(ptrvector);
713| 32.0k| for (i = 0; i < n; i++) {
------------------
| Branch (713:17): [True: 17.8k, False: 14.2k]
------------------
714| 17.8k| if (!strcmp(
------------------
| Branch (714:13): [True: 1, False: 17.8k]
------------------
715| 17.8k| attr_name,
716| 17.8k| ((igraph_i_graphml_attribute_record_t*) igraph_vector_ptr_get(ptrvector, i))->record.name
717| 17.8k| )) {
718| 1| IGRAPH_ERRORF(
------------------
| | 464| 1| do { \
| | 465| 1| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 1| igraph_errno, __VA_ARGS__) ; \
| | 467| 1| return igraph_errno; \
| | 468| 1| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
719| 1| "Duplicate attribute name found: '%s' (for ).",
720| 1| IGRAPH_PARSEERROR, attr_name, rec->id
721| 1| );
722| 1| }
723| 17.8k| }
724| |
725| | /* add to trie, attributes */
726| 14.2k| IGRAPH_CHECK(igraph_trie_get(trie, rec->id, &id));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
727| 14.2k| IGRAPH_CHECK(igraph_vector_ptr_push_back(ptrvector, rec));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
728| |
729| | /* Ownership of 'rec' is now taken by ptrvector so we are not responsible
730| | * for destroying and freeing it any more */
731| 14.2k| IGRAPH_FINALLY_CLEAN(2);
732| |
733| | /* create the attribute values */
734| 14.2k| IGRAPH_CHECK(igraph_attribute_record_init(&rec->record, attr_name, igraph_attr_type));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
735| |
736| 16.9k|exit:
737| 16.9k| safely_free_optional_string(&attr_name);
738| 16.9k| IGRAPH_FINALLY_CLEAN(1);
739| |
740| 16.9k| *record = rec;
741| 16.9k| return IGRAPH_SUCCESS;
742| 14.2k|}
graphml.c:safely_free_optional_string:
525| 44.6k|static void safely_free_optional_string(char** str) {
526| 44.6k| if (*str != NULL) {
------------------
| Branch (526:9): [True: 17.0k, False: 27.6k]
------------------
527| 17.0k| igraph_free(*str);
528| | *str = NULL;
529| 17.0k| }
530| 44.6k|}
graphml.c:safely_convert_xml_attribute_to_string:
504| 27.3k|static igraph_error_t safely_convert_xml_attribute_to_string(xmlChar** it, char** str) {
505| | /* This is quite convoluted but we need to go safely from xmlChar*-world
506| | * to char*-world */
507| 27.3k| xmlChar *xml_str;
508| 27.3k| char *c_str;
509| |
510| 27.3k| xml_str = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 27.3k|#define XML_ATTR_VALUE(it) it[3], (int)(it[4] - it[3]) /* for use in strnxxx()-style functions that take a char * and a length */
------------------
511| 27.3k| IGRAPH_CHECK_OOM(xml_str, "Insufficient memory to duplicate attribute value.");
------------------
| | 709| 27.3k| do { \
| | 710| 27.3k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 27.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.3k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 27.3k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 27.3k]
| | ------------------
------------------
512| 27.3k| IGRAPH_FINALLY(xmlFree, xml_str);
------------------
| | 603| 27.3k| do { \
| | 604| 27.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 27.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 27.3k| * incorrect destructor function with the pointer */ \
| | 607| 27.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 27.3k]
| | ------------------
| | 608| 27.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 27.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 27.3k]
| | ------------------
------------------
513| |
514| 27.3k| c_str = strdup(fromXmlChar(xml_str));
------------------
| | 76| 27.3k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
515| 27.3k| IGRAPH_CHECK_OOM(c_str, "Insufficient memory to duplicate attribute value.");
------------------
| | 709| 27.3k| do { \
| | 710| 27.3k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 27.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.3k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 27.3k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 27.3k]
| | ------------------
------------------
516| |
517| 27.3k| *str = c_str;
518| |
519| 27.3k| xmlFree(xml_str);
520| 27.3k| IGRAPH_FINALLY_CLEAN(1);
521| |
522| 27.3k| return IGRAPH_SUCCESS;
523| 27.3k|}
graphml.c:igraph_i_report_unhandled_attribute_target:
132| 1.30k| const char* file, int line) {
133| 1.30k| igraph_warningf("Attribute target '%s' is not handled; ignoring corresponding "
134| 1.30k| "attribute specifications.", file, line, target);
135| 1.30k|}
graphml.c:igraph_i_graphml_attribute_data_setup:
747| 418k|) {
748| 418k| xmlChar **it;
749| 418k| int i;
750| |
751| 418k| if (!state->successful) {
------------------
| Branch (751:9): [True: 0, False: 418k]
------------------
752| 0| return IGRAPH_SUCCESS;
753| 0| }
754| |
755| 834k| for (i = 0, it = (xmlChar**)attrs; i < nb_attrs; i++, it += 5) {
------------------
| Branch (755:40): [True: 416k, False: 418k]
------------------
756| 416k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 416k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (756:13): [True: 76, False: 416k]
------------------
757| 76| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 76|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 76|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 76|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (757:13): [True: 66, False: 10]
------------------
758| 66| continue;
759| 66| }
760| |
761| 416k| if (xmlStrEqual(*it, toXmlChar("key"))) {
------------------
| | 75| 416k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 416k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (761:13): [True: 416k, False: 520]
------------------
762| 416k| if (state->data_key) {
------------------
| Branch (762:17): [True: 412k, False: 3.58k]
------------------
763| 412k| xmlFree((void *) state->data_key);
764| 412k| state->data_key = NULL;
765| 412k| }
766| 416k| state->data_key = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 416k|#define XML_ATTR_VALUE(it) it[3], (int)(it[4] - it[3]) /* for use in strnxxx()-style functions that take a char * and a length */
------------------
767| 416k| IGRAPH_CHECK_OOM(state->data_key, "Insufficient memory to read GraphML file.");
------------------
| | 709| 416k| do { \
| | 710| 416k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 416k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 416k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 416k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 416k]
| | ------------------
------------------
768| 416k| igraph_vector_char_clear(&state->data_char);
769| 416k| state->data_type = type;
770| 416k| } else {
771| | /* ignore */
772| 520| }
773| 416k| }
774| |
775| 418k| return IGRAPH_SUCCESS;
776| 418k|}
graphml.c:igraph_i_graphml_sax_handler_end_element_ns:
1280| 1.26M| const xmlChar* uri) {
1281| 1.26M| struct igraph_i_graphml_parser_state *state =
1282| 1.26M| (struct igraph_i_graphml_parser_state*)state0;
1283| 1.26M| igraph_error_t result;
1284| |
1285| 1.26M| if (!state->successful) {
------------------
| Branch (1285:9): [True: 6.30k, False: 1.26M]
------------------
1286| 6.30k| return;
1287| 6.30k| }
1288| |
1289| 1.26M| result = igraph_i_graphml_sax_handler_end_element_ns_inner(
1290| 1.26M| state, localname, prefix, uri
1291| 1.26M| );
1292| |
1293| 1.26M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1293:9): [True: 97, False: 1.26M]
------------------
1294| 97| RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file.", result);
------------------
| | 85| 97| do { \
| | 86| 97| GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code); \
| | ------------------
| | | | 79| 97| do { \
| | | | 80| 97| if (state->successful) { \
| | | | ------------------
| | | | | Branch (80:13): [True: 97, False: 0]
| | | | ------------------
| | | | 81| 97| igraph_i_graphml_sax_handler_error(state, msg); \
| | | | 82| 97| } \
| | | | 83| 97| } while (0)
| | | | ------------------
| | | | | Branch (83:14): [Folded, False: 97]
| | | | ------------------
| | ------------------
| | 87| 97| return; \
| | 88| 97| } while (0)
| | ------------------
| | | Branch (88:14): [Folded, False: 0]
| | ------------------
------------------
1295| 97| }
1296| 1.26M|}
graphml.c:igraph_i_graphml_sax_handler_end_element_ns_inner:
1221| 1.26M|) {
1222| 1.26M| IGRAPH_UNUSED(localname);
------------------
| | 30| 1.26M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1223| 1.26M| IGRAPH_UNUSED(prefix);
------------------
| | 30| 1.26M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1224| 1.26M| IGRAPH_UNUSED(uri);
------------------
| | 30| 1.26M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1225| |
1226| 1.26M| switch (state->st) {
1227| 6.65k| case INSIDE_GRAPHML:
------------------
| Branch (1227:5): [True: 6.65k, False: 1.25M]
------------------
1228| 6.65k| state->st = FINISH;
1229| 6.65k| break;
1230| |
1231| 6.69k| case INSIDE_GRAPH:
------------------
| Branch (1231:5): [True: 6.69k, False: 1.25M]
------------------
1232| 6.69k| state->st = INSIDE_GRAPHML;
1233| 6.69k| break;
1234| |
1235| 16.6k| case INSIDE_KEY:
------------------
| Branch (1235:5): [True: 16.6k, False: 1.24M]
------------------
1236| 16.6k| state->current_attr_record = NULL;
1237| 16.6k| state->st = INSIDE_GRAPHML;
1238| 16.6k| break;
1239| |
1240| 3.45k| case INSIDE_DEFAULT:
------------------
| Branch (1240:5): [True: 3.45k, False: 1.25M]
------------------
1241| 3.45k| IGRAPH_CHECK(igraph_i_graphml_attribute_default_value_finish(state));
------------------
| | 656| 3.45k| do { \
| | 657| 3.45k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 68, False: 3.38k]
| | | | ------------------
| | ------------------
| | 659| 68| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 68| do { \
| | | | 427| 68| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 68| return igraph_errno ; \
| | | | 429| 68| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 68| } \
| | 661| 3.45k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.38k]
| | ------------------
------------------
1242| 3.38k| state->st = INSIDE_KEY;
1243| 3.38k| break;
1244| |
1245| 34.2k| case INSIDE_NODE:
------------------
| Branch (1245:5): [True: 34.2k, False: 1.22M]
------------------
1246| 34.2k| state->st = INSIDE_GRAPH;
1247| 34.2k| break;
1248| |
1249| 696k| case INSIDE_EDGE:
------------------
| Branch (1249:5): [True: 696k, False: 566k]
------------------
1250| 696k| state->st = INSIDE_GRAPH;
1251| 696k| break;
1252| |
1253| 418k| case INSIDE_DATA:
------------------
| Branch (1253:5): [True: 418k, False: 844k]
------------------
1254| 418k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_finish(state));
------------------
| | 656| 418k| do { \
| | 657| 418k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 418k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 418k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 29, False: 418k]
| | | | ------------------
| | ------------------
| | 659| 29| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 29| do { \
| | | | 427| 29| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 29| return igraph_errno ; \
| | | | 429| 29| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 29| } \
| | 661| 418k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 418k]
| | ------------------
------------------
1255| 418k| IGRAPH_ASSERT(!igraph_vector_int_empty(&state->prev_state_stack));
------------------
| | 924| 418k| do { \
| | 925| 418k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 418k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 418k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 418k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 418k]
| | ------------------
------------------
1256| 418k| state->st = (igraph_i_graphml_parser_state_index_t) igraph_vector_int_pop_back(&state->prev_state_stack);
1257| 418k| break;
1258| |
1259| 79.2k| case UNKNOWN:
------------------
| Branch (1259:5): [True: 79.2k, False: 1.18M]
------------------
1260| 79.2k| state->unknown_depth--;
1261| 79.2k| if (!state->unknown_depth) {
------------------
| Branch (1261:13): [True: 8.31k, False: 70.9k]
------------------
1262| 8.31k| IGRAPH_ASSERT(!igraph_vector_int_empty(&state->prev_state_stack));
------------------
| | 924| 8.31k| do { \
| | 925| 8.31k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.31k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.31k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.31k]
| | ------------------
------------------
1263| 8.31k| state->st = (igraph_i_graphml_parser_state_index_t) igraph_vector_int_pop_back(&state->prev_state_stack);
1264| 8.31k| }
1265| 79.2k| break;
1266| |
1267| 79.2k| case FINISH:
------------------
| Branch (1267:5): [True: 1.21k, False: 1.26M]
------------------
1268| 1.21k| break;
1269| |
1270| 0| default:
------------------
| Branch (1270:5): [True: 0, False: 1.26M]
------------------
1271| 0| IGRAPH_FATALF("Unexpected GraphML reader state %d.", (int) state->st);
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
1272| 1.26M| }
1273| |
1274| 1.26M| return IGRAPH_SUCCESS;
1275| 1.26M|}
graphml.c:igraph_i_graphml_attribute_default_value_finish:
899| 3.45k|static igraph_error_t igraph_i_graphml_attribute_default_value_finish(struct igraph_i_graphml_parser_state *state) {
900| 3.45k| igraph_i_graphml_attribute_record_t *graphmlrec = state->current_attr_record;
901| 3.45k| igraph_attribute_record_t *rec;
902| 3.45k| igraph_error_t result = IGRAPH_SUCCESS;
903| 3.45k| igraph_real_t default_num;
904| 3.45k| igraph_bool_t default_bool;
905| |
906| 3.45k| IGRAPH_ASSERT(state->current_attr_record != NULL);
------------------
| | 924| 3.45k| do { \
| | 925| 3.45k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.45k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.45k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.45k]
| | ------------------
------------------
907| |
908| 3.45k| if (igraph_vector_char_size(&state->data_char) == 0) {
------------------
| Branch (908:9): [True: 239, False: 3.21k]
------------------
909| 239| return IGRAPH_SUCCESS;
910| 239| }
911| |
912| 3.21k| rec = &graphmlrec->record;
913| |
914| 3.21k| switch (rec->type) {
915| 1.50k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (915:5): [True: 1.50k, False: 1.71k]
------------------
916| | /* Add null terminator */
917| 1.50k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 1.50k| do { \
| | 657| 1.50k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.50k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.50k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.50k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.50k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.50k]
| | ------------------
------------------
918| 1.50k| IGRAPH_CHECK(igraph_i_graphml_parse_boolean(VECTOR(state->data_char), &default_bool, false));
------------------
| | 656| 1.50k| do { \
| | 657| 1.50k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.50k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.50k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 63, False: 1.44k]
| | | | ------------------
| | ------------------
| | 659| 63| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 63| do { \
| | | | 427| 63| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 63| return igraph_errno ; \
| | | | 429| 63| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 63| } \
| | 661| 1.50k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.44k]
| | ------------------
------------------
919| 1.44k| IGRAPH_CHECK(igraph_attribute_record_set_default_boolean(rec, default_bool));
------------------
| | 656| 1.44k| do { \
| | 657| 1.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.44k]
| | ------------------
------------------
920| 1.44k| break;
921| 1.44k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (921:5): [True: 485, False: 2.72k]
------------------
922| | /* Add null terminator */
923| 485| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 485| do { \
| | 657| 485| igraph_error_t igraph_i_ret = (expr); \
| | 658| 485| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 485| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 485]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 485| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 485]
| | ------------------
------------------
924| 485| IGRAPH_CHECK(igraph_i_graphml_parse_numeric(VECTOR(state->data_char), &default_num, IGRAPH_NAN));
------------------
| | 656| 485| do { \
| | 657| 485| igraph_error_t igraph_i_ret = (expr); \
| | 658| 485| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 485| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 5, False: 480]
| | | | ------------------
| | ------------------
| | 659| 5| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 5| do { \
| | | | 427| 5| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 5| return igraph_errno ; \
| | | | 429| 5| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 5| } \
| | 661| 485| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 480]
| | ------------------
------------------
925| 480| IGRAPH_CHECK(igraph_attribute_record_set_default_numeric(rec, default_num));
------------------
| | 656| 480| do { \
| | 657| 480| igraph_error_t igraph_i_ret = (expr); \
| | 658| 480| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 480| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 480]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 480| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 480]
| | ------------------
------------------
926| 480| break;
927| 973| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (927:5): [True: 973, False: 2.24k]
------------------
928| | /* Add null terminator */
929| 973| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 973| do { \
| | 657| 973| igraph_error_t igraph_i_ret = (expr); \
| | 658| 973| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 973| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 973]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 973| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 973]
| | ------------------
------------------
930| 973| IGRAPH_CHECK(igraph_attribute_record_set_default_string(rec, VECTOR(state->data_char)));
------------------
| | 656| 973| do { \
| | 657| 973| igraph_error_t igraph_i_ret = (expr); \
| | 658| 973| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 973| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 973]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 973| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 973]
| | ------------------
------------------
931| 973| break;
932| 973| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (932:5): [True: 252, False: 2.96k]
------------------
933| 252| break;
934| 0| default:
------------------
| Branch (934:5): [True: 0, False: 3.21k]
------------------
935| 0| IGRAPH_FATAL("Unexpected attribute type.");
------------------
| | 895| 0| do { \
| | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 897| 0| } while (0)
| | ------------------
| | | Branch (897:14): [Folded, False: 0]
| | ------------------
------------------
936| 3.21k| }
937| |
938| 3.14k| igraph_vector_char_clear(&state->data_char);
939| |
940| 3.14k| return result;
941| 3.21k|}
graphml.c:igraph_i_graphml_parse_boolean:
160| 12.7k|) {
161| 12.7k| igraph_int_t value;
162| 12.7k| const char* trimmed;
163| 12.7k| size_t trimmed_length;
164| |
165| 12.7k| if (char_data == 0) {
------------------
| Branch (165:9): [True: 0, False: 12.7k]
------------------
166| 0| *result = default_value;
167| 0| return IGRAPH_SUCCESS;
168| 0| }
169| |
170| 12.7k| igraph_i_trim_whitespace(char_data, strlen(char_data), &trimmed, &trimmed_length);
171| |
172| 12.7k| if (trimmed_length == 4 && !strncasecmp(trimmed, "true", trimmed_length)) {
------------------
| Branch (172:9): [True: 548, False: 12.2k]
| Branch (172:32): [True: 224, False: 324]
------------------
173| 224| *result = 1;
174| 224| return IGRAPH_SUCCESS;
175| 224| }
176| |
177| 12.5k| if (trimmed_length == 3 && !strncasecmp(trimmed, "yes", trimmed_length)) {
------------------
| Branch (177:9): [True: 153, False: 12.4k]
| Branch (177:32): [True: 66, False: 87]
------------------
178| 66| *result = 1;
179| 66| return IGRAPH_SUCCESS;
180| 66| }
181| |
182| 12.4k| if (trimmed_length == 5 && !strncasecmp(trimmed, "false", trimmed_length)) {
------------------
| Branch (182:9): [True: 11.3k, False: 1.16k]
| Branch (182:32): [True: 11.2k, False: 90]
------------------
183| 11.2k| *result = 0;
184| 11.2k| return IGRAPH_SUCCESS;
185| 11.2k| }
186| |
187| 1.25k| if (trimmed_length == 2 && !strncasecmp(trimmed, "no", trimmed_length)) {
------------------
| Branch (187:9): [True: 403, False: 855]
| Branch (187:32): [True: 197, False: 206]
------------------
188| 197| *result = 0;
189| 197| return IGRAPH_SUCCESS;
190| 197| }
191| |
192| 1.06k| if (trimmed_length > 0) {
------------------
| Branch (192:9): [True: 857, False: 204]
------------------
193| 857| if (isdigit(trimmed[0])) {
------------------
| Branch (193:13): [True: 807, False: 50]
------------------
194| 807| IGRAPH_CHECK(igraph_i_parse_integer(trimmed, trimmed_length, &value));
------------------
| | 656| 807| do { \
| | 657| 807| igraph_error_t igraph_i_ret = (expr); \
| | 658| 807| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 807| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 27, False: 780]
| | | | ------------------
| | ------------------
| | 659| 27| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 27| do { \
| | | | 427| 27| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 27| return igraph_errno ; \
| | | | 429| 27| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 27| } \
| | 661| 807| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 780]
| | ------------------
------------------
195| 807| } else {
196| 50| IGRAPH_ERRORF("Cannot parse '%.*s' as Boolean value.", IGRAPH_PARSEERROR,
------------------
| | 464| 50| do { \
| | 465| 50| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 50| igraph_errno, __VA_ARGS__) ; \
| | 467| 50| return igraph_errno; \
| | 468| 50| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
197| 50| (int) trimmed_length, trimmed);
198| 50| }
199| 857| } else {
200| 204| *result = default_value;
201| 204| return IGRAPH_SUCCESS;
202| 204| }
203| |
204| 780| *result = value != 0;
205| 780| return IGRAPH_SUCCESS;
206| 1.06k|}
graphml.c:igraph_i_graphml_parse_numeric:
139| 6.88k|) {
140| 6.88k| const char* trimmed;
141| 6.88k| size_t trimmed_length;
142| |
143| 6.88k| if (char_data == 0) {
------------------
| Branch (143:9): [True: 0, False: 6.88k]
------------------
144| 0| *result = default_value;
145| 0| return IGRAPH_SUCCESS;
146| 0| }
147| |
148| 6.88k| igraph_i_trim_whitespace(char_data, strlen(char_data), &trimmed, &trimmed_length);
149| 6.88k| if (trimmed_length > 0) {
------------------
| Branch (149:9): [True: 6.39k, False: 495]
------------------
150| 6.39k| IGRAPH_CHECK(igraph_i_parse_real(trimmed, trimmed_length, result));
------------------
| | 656| 6.39k| do { \
| | 657| 6.39k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 20, False: 6.37k]
| | | | ------------------
| | ------------------
| | 659| 20| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 20| do { \
| | | | 427| 20| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 20| return igraph_errno ; \
| | | | 429| 20| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 20| } \
| | 661| 6.39k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.37k]
| | ------------------
------------------
151| 6.39k| } else {
152| 495| *result = default_value;
153| 495| }
154| |
155| 6.86k| return IGRAPH_SUCCESS;
156| 6.88k|}
graphml.c:igraph_i_graphml_attribute_data_finish:
797| 418k|static igraph_error_t igraph_i_graphml_attribute_data_finish(struct igraph_i_graphml_parser_state *state) {
798| 418k| const char *key = fromXmlChar(state->data_key);
------------------
| | 76| 418k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
799| 418k| igraph_attribute_elemtype_t type = state->data_type;
800| 418k| igraph_trie_t *trie = NULL;
801| 418k| igraph_vector_ptr_t *ptrvector = NULL;
802| 418k| igraph_i_graphml_attribute_record_t *graphmlrec;
803| 418k| igraph_attribute_record_t *rec;
804| 418k| igraph_int_t recid, id = 0;
805| 418k| igraph_error_t result = IGRAPH_SUCCESS;
806| |
807| 418k| switch (type) {
808| 3.49k| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (808:5): [True: 3.49k, False: 414k]
------------------
809| 3.49k| trie = &state->g_attr_ids;
810| 3.49k| ptrvector = &state->g_attrs;
811| 3.49k| id = 0;
812| 3.49k| break;
813| 51.6k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (813:5): [True: 51.6k, False: 366k]
------------------
814| 51.6k| trie = &state->v_attr_ids;
815| 51.6k| ptrvector = &state->v_attrs;
816| 51.6k| id = state->act_node;
817| 51.6k| break;
818| 362k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (818:5): [True: 362k, False: 55.1k]
------------------
819| 362k| trie = &state->e_attr_ids;
820| 362k| ptrvector = &state->e_attrs;
821| 362k| id = igraph_vector_int_size(&state->edgelist) / 2 - 1; /* hack */
822| 362k| break;
823| 0| default:
------------------
| Branch (823:5): [True: 0, False: 418k]
------------------
824| 0| IGRAPH_FATAL("Unexpected attribute element type.");
------------------
| | 895| 0| do { \
| | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 897| 0| } while (0)
| | ------------------
| | | Branch (897:14): [Folded, False: 0]
| | ------------------
------------------
825| 418k| }
826| |
827| 418k| if (key == 0) {
------------------
| Branch (827:9): [True: 308, False: 417k]
------------------
828| | /* no key specified, issue a warning */
829| 308| IGRAPH_WARNING("Missing attribute key in a tag, ignoring attribute.");
------------------
| | 797| 308| do { \
| | 798| 308| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 308| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 308]
| | ------------------
------------------
830| 308| goto exit;
831| 308| }
832| |
833| 417k| IGRAPH_CHECK(igraph_trie_check(trie, key, &recid));
------------------
| | 656| 417k| do { \
| | 657| 417k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 417k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 417k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 417k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 417k]
| | ------------------
------------------
834| 417k| if (recid < 0) {
------------------
| Branch (834:9): [True: 1.66k, False: 416k]
------------------
835| | /* no such attribute key, issue a warning */
836| 1.66k| IGRAPH_WARNINGF(
------------------
| | 777| 1.66k| do { \
| | 778| 1.66k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 1.66k| __VA_ARGS__); \
| | 780| 1.66k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 1.66k]
| | ------------------
------------------
837| 1.66k| "Unknown attribute key '%s' in a tag, ignoring attribute.",
838| 1.66k| key
839| 1.66k| );
840| 1.66k| goto exit;
841| 1.66k| }
842| |
843| 416k| graphmlrec = VECTOR(*ptrvector)[recid];
------------------
| | 60| 416k|#define VECTOR(v) ((v).stor_begin)
------------------
844| 416k| rec = &graphmlrec->record;
845| |
846| 416k| if (id >= igraph_attribute_record_size(rec) && rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (846:9): [True: 415k, False: 769]
| Branch (846:52): [True: 414k, False: 349]
------------------
847| 414k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, id + 1));
------------------
| | 656| 414k| do { \
| | 657| 414k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 414k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 414k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 414k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 414k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 414k]
| | ------------------
------------------
848| 414k| }
849| |
850| 416k| switch (rec->type) {
851| 0| igraph_vector_bool_t *boolvec;
852| 0| igraph_vector_t *vec;
853| 0| igraph_strvector_t *strvec;
854| 0| const char* strvalue;
855| |
856| 11.2k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (856:5): [True: 11.2k, False: 404k]
------------------
857| | /* Add null terminator */
858| 11.2k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 11.2k| do { \
| | 657| 11.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 11.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.2k]
| | ------------------
------------------
859| 11.2k| boolvec = rec->value.as_vector_bool;
860| 11.2k| IGRAPH_CHECK(igraph_i_graphml_parse_boolean(
------------------
| | 656| 11.2k| do { \
| | 657| 11.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 14, False: 11.2k]
| | | | ------------------
| | ------------------
| | 659| 14| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 14| do { \
| | | | 427| 14| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 14| return igraph_errno ; \
| | | | 429| 14| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 14| } \
| | 661| 11.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.2k]
| | ------------------
------------------
861| 11.2k| VECTOR(state->data_char), VECTOR(*boolvec) + id, rec->default_value.boolean
862| 11.2k| ));
863| 11.2k| break;
864| |
865| 11.2k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (865:5): [True: 6.40k, False: 409k]
------------------
866| | /* Add null terminator */
867| 6.40k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 6.40k| do { \
| | 657| 6.40k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.40k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.40k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.40k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.40k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.40k]
| | ------------------
------------------
868| 6.40k| vec = rec->value.as_vector;
869| 6.40k| IGRAPH_CHECK(igraph_i_graphml_parse_numeric(
------------------
| | 656| 6.40k| do { \
| | 657| 6.40k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.40k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.40k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 15, False: 6.38k]
| | | | ------------------
| | ------------------
| | 659| 15| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 15| do { \
| | | | 427| 15| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 15| return igraph_errno ; \
| | | | 429| 15| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 15| } \
| | 661| 6.40k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.38k]
| | ------------------
------------------
870| 6.40k| VECTOR(state->data_char), VECTOR(*vec) + id, rec->default_value.numeric
871| 6.40k| ));
872| 6.38k| break;
873| |
874| 398k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (874:5): [True: 398k, False: 18.0k]
------------------
875| | /* Ensure that the vector ends with a null terminator */
876| 398k| strvec = rec->value.as_strvector;
877| 398k| if (igraph_vector_char_size(&state->data_char) > 0) {
------------------
| Branch (877:13): [True: 285k, False: 112k]
------------------
878| 285k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 285k| do { \
| | 657| 285k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 285k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 285k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 285k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 285k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 285k]
| | ------------------
------------------
879| 285k| strvalue = VECTOR(state->data_char);
------------------
| | 60| 285k|#define VECTOR(v) ((v).stor_begin)
------------------
880| 285k| } else {
881| 112k| strvalue = rec->default_value.string;
882| 112k| }
883| 398k| IGRAPH_CHECK(igraph_strvector_set(strvec, id, strvalue ? strvalue : ""));
------------------
| | 656| 398k| do { \
| | 657| 796k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 285k, False: 112k]
| | ------------------
| | 658| 398k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 398k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 398k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 398k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 398k]
| | ------------------
------------------
884| 398k| break;
885| |
886| 398k| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (886:5): [True: 349, False: 415k]
------------------
887| 349| break;
888| |
889| 0| default:
------------------
| Branch (889:5): [True: 0, False: 416k]
------------------
890| 0| IGRAPH_FATAL("Unexpected attribute type.");
------------------
| | 895| 0| do { \
| | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 897| 0| } while (0)
| | ------------------
| | | Branch (897:14): [Folded, False: 0]
| | ------------------
------------------
891| 416k| }
892| |
893| 418k|exit:
894| 418k| igraph_vector_char_clear(&state->data_char);
895| |
896| 418k| return result;
897| 416k|}
graphml.c:igraph_i_graphml_parser_state_finish_parsing:
389| 6.64k|static igraph_error_t igraph_i_graphml_parser_state_finish_parsing(struct igraph_i_graphml_parser_state *state) {
390| 6.64k| igraph_int_t i;
391| 6.64k| const char *idstr = "id";
392| 6.64k| igraph_bool_t already_has_vertex_id = false, already_has_edge_id = false;
393| 6.64k| igraph_attribute_record_list_t vattr, eattr, gattr;
394| 6.64k| igraph_attribute_record_t *idrec;
395| |
396| 6.64k| IGRAPH_ASSERT(state->successful);
------------------
| | 924| 6.64k| do { \
| | 925| 6.64k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.64k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.64k]
| | ------------------
------------------
397| |
398| | /* check that we have found and parsed the graph the user is interested in */
399| 6.64k| IGRAPH_ASSERT(state->index < 0);
------------------
| | 924| 6.64k| do { \
| | 925| 6.64k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.64k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.64k]
| | ------------------
------------------
400| |
401| 6.64k| IGRAPH_CHECK(igraph_attribute_record_list_init(&vattr, 0));
------------------
| | 656| 6.64k| do { \
| | 657| 6.64k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.64k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.64k]
| | ------------------
------------------
402| 6.64k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &vattr);
------------------
| | 603| 6.64k| do { \
| | 604| 6.64k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.64k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.64k| * incorrect destructor function with the pointer */ \
| | 607| 6.64k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.64k]
| | ------------------
| | 608| 6.64k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.64k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.64k]
| | ------------------
------------------
403| 6.64k| IGRAPH_CHECK(igraph_attribute_record_list_init(&eattr, 0));
------------------
| | 656| 6.64k| do { \
| | 657| 6.64k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.64k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.64k]
| | ------------------
------------------
404| 6.64k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &eattr);
------------------
| | 603| 6.64k| do { \
| | 604| 6.64k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.64k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.64k| * incorrect destructor function with the pointer */ \
| | 607| 6.64k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.64k]
| | ------------------
| | 608| 6.64k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.64k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.64k]
| | ------------------
------------------
405| 6.64k| IGRAPH_CHECK(igraph_attribute_record_list_init(&gattr, 0));
------------------
| | 656| 6.64k| do { \
| | 657| 6.64k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.64k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.64k]
| | ------------------
------------------
406| 6.64k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &gattr);
------------------
| | 603| 6.64k| do { \
| | 604| 6.64k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.64k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.64k| * incorrect destructor function with the pointer */ \
| | 607| 6.64k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.64k]
| | ------------------
| | 608| 6.64k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.64k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.64k]
| | ------------------
------------------
407| |
408| | /* Add default attribute values for vertices where needed */
409| 13.5k| for (i = 0; i < igraph_vector_ptr_size(&state->v_attrs); i++) {
------------------
| Branch (409:17): [True: 6.91k, False: 6.64k]
------------------
410| 6.91k| igraph_i_graphml_attribute_record_t *graphmlrec =
411| 6.91k| VECTOR(state->v_attrs)[i];
------------------
| | 60| 6.91k|#define VECTOR(v) ((v).stor_begin)
------------------
412| 6.91k| igraph_attribute_record_t *rec = &graphmlrec->record;
413| |
414| | /* Check that the name of the vertex attribute is not 'id'.
415| | * If it is then we cannot add the complementary 'id' attribute. */
416| 6.91k| if (!strcmp(rec->name, idstr)) {
------------------
| Branch (416:13): [True: 3.35k, False: 3.56k]
------------------
417| 3.35k| already_has_vertex_id = 1;
418| 3.35k| }
419| |
420| 6.91k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (420:13): [True: 6.87k, False: 47]
------------------
421| 6.87k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, igraph_trie_size(&state->node_trie)));
------------------
| | 656| 6.87k| do { \
| | 657| 6.87k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.87k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.87k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.87k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.87k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.87k]
| | ------------------
------------------
422| 6.87k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&vattr, rec));
------------------
| | 656| 6.87k| do { \
| | 657| 6.87k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.87k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.87k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.87k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.87k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.87k]
| | ------------------
------------------
423| 6.87k| graphmlrec->record_disowned = true;
424| 6.87k| }
425| 6.91k| }
426| |
427| | /* Add vertex ID attribute if needed */
428| 6.64k| if (!already_has_vertex_id) {
------------------
| Branch (428:9): [True: 3.28k, False: 3.35k]
------------------
429| 3.28k| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(&vattr, &idrec));
------------------
| | 656| 3.28k| do { \
| | 657| 3.28k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.28k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.28k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.28k]
| | ------------------
------------------
430| 3.28k| IGRAPH_CHECK(igraph_attribute_record_set_name(idrec, idstr));
------------------
| | 656| 3.28k| do { \
| | 657| 3.28k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.28k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.28k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.28k]
| | ------------------
------------------
431| 3.28k| IGRAPH_CHECK(igraph_attribute_record_set_type(idrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.28k| do { \
| | 657| 3.28k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.28k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.28k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.28k]
| | ------------------
------------------
432| 3.28k| IGRAPH_CHECK(igraph_strvector_update(idrec->value.as_strvector, igraph_i_trie_borrow_keys(&state->node_trie)));
------------------
| | 656| 3.28k| do { \
| | 657| 3.28k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.28k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.28k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.28k]
| | ------------------
------------------
433| 3.35k| } else {
434| 3.35k| IGRAPH_WARNING("Could not add vertex ids, there is already an 'id' vertex attribute.");
------------------
| | 797| 3.35k| do { \
| | 798| 3.35k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 3.35k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 3.35k]
| | ------------------
------------------
435| 3.35k| }
436| |
437| | /* Add default attribute values for edges where needed */
438| 11.4k| for (i = 0; i < igraph_vector_ptr_size(&state->e_attrs); i++) {
------------------
| Branch (438:17): [True: 4.77k, False: 6.64k]
------------------
439| 4.77k| igraph_i_graphml_attribute_record_t *graphmlrec =
440| 4.77k| VECTOR(state->e_attrs)[i];
------------------
| | 60| 4.77k|#define VECTOR(v) ((v).stor_begin)
------------------
441| 4.77k| igraph_attribute_record_t *rec = &graphmlrec->record;
442| |
443| 4.77k| if (!strcmp(rec->name, idstr)) {
------------------
| Branch (443:13): [True: 912, False: 3.86k]
------------------
444| 912| already_has_edge_id = 1;
445| 912| }
446| |
447| 4.77k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (447:13): [True: 4.60k, False: 168]
------------------
448| 4.60k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, igraph_vector_int_size(&state->edgelist) / 2));
------------------
| | 656| 4.60k| do { \
| | 657| 4.60k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.60k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.60k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.60k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.60k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.60k]
| | ------------------
------------------
449| 4.60k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&eattr, rec));
------------------
| | 656| 4.60k| do { \
| | 657| 4.60k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.60k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.60k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.60k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.60k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.60k]
| | ------------------
------------------
450| 4.60k| graphmlrec->record_disowned = true;
451| 4.60k| }
452| 4.77k| }
453| |
454| | /* Add edge ID attribute if needed */
455| 6.64k| if (igraph_strvector_size(&state->edgeids) != 0) {
------------------
| Branch (455:9): [True: 913, False: 5.72k]
------------------
456| 913| if (!already_has_edge_id) {
------------------
| Branch (456:13): [True: 912, False: 1]
------------------
457| 912| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(&eattr, &idrec));
------------------
| | 656| 912| do { \
| | 657| 912| igraph_error_t igraph_i_ret = (expr); \
| | 658| 912| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 912| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 912]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 912| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 912]
| | ------------------
------------------
458| 912| IGRAPH_CHECK(igraph_attribute_record_set_name(idrec, idstr));
------------------
| | 656| 912| do { \
| | 657| 912| igraph_error_t igraph_i_ret = (expr); \
| | 658| 912| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 912| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 912]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 912| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 912]
| | ------------------
------------------
459| 912| IGRAPH_CHECK(igraph_attribute_record_set_type(idrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 912| do { \
| | 657| 912| igraph_error_t igraph_i_ret = (expr); \
| | 658| 912| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 912| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 912]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 912| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 912]
| | ------------------
------------------
460| 912| IGRAPH_CHECK(igraph_strvector_update(idrec->value.as_strvector, &state->edgeids));
------------------
| | 656| 912| do { \
| | 657| 912| igraph_error_t igraph_i_ret = (expr); \
| | 658| 912| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 912| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 912]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 912| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 912]
| | ------------------
------------------
461| 912| IGRAPH_CHECK(igraph_attribute_record_resize(idrec, igraph_vector_int_size(&state->edgelist) / 2));
------------------
| | 656| 912| do { \
| | 657| 912| igraph_error_t igraph_i_ret = (expr); \
| | 658| 912| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 912| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 912]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 912| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 912]
| | ------------------
------------------
462| 912| } else {
463| 1| IGRAPH_WARNING("Could not add edge ids, there is already an 'id' edge attribute.");
------------------
| | 797| 1| do { \
| | 798| 1| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 1| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 1]
| | ------------------
------------------
464| 1| }
465| 913| }
466| |
467| | /* Add default graph attribute values where needed */
468| 8.36k| for (i = 0; i < igraph_vector_ptr_size(&state->g_attrs); i++) {
------------------
| Branch (468:17): [True: 1.72k, False: 6.64k]
------------------
469| 1.72k| igraph_i_graphml_attribute_record_t *graphmlrec =
470| 1.72k| VECTOR(state->g_attrs)[i];
------------------
| | 60| 1.72k|#define VECTOR(v) ((v).stor_begin)
------------------
471| 1.72k| igraph_attribute_record_t *rec = &graphmlrec->record;
472| |
473| 1.72k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (473:13): [True: 1.66k, False: 57]
------------------
474| 1.66k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, 1));
------------------
| | 656| 1.66k| do { \
| | 657| 1.66k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.66k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.66k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.66k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.66k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.66k]
| | ------------------
------------------
475| 1.66k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&gattr, rec));
------------------
| | 656| 1.66k| do { \
| | 657| 1.66k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.66k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.66k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.66k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.66k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.66k]
| | ------------------
------------------
476| 1.66k| graphmlrec->record_disowned = true;
477| 1.66k| }
478| 1.72k| }
479| |
480| 6.64k| IGRAPH_CHECK(igraph_empty_attrs(state->g, 0, state->edges_directed, &gattr));
------------------
| | 656| 6.64k| do { \
| | 657| 6.64k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.64k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.64k]
| | ------------------
------------------
481| 6.64k| IGRAPH_FINALLY(igraph_destroy, state->g); /* because the next two lines may fail as well */
------------------
| | 603| 6.64k| do { \
| | 604| 6.64k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.64k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.64k| * incorrect destructor function with the pointer */ \
| | 607| 6.64k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.64k]
| | ------------------
| | 608| 6.64k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.64k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.64k]
| | ------------------
------------------
482| 6.64k| IGRAPH_CHECK(igraph_add_vertices(state->g, igraph_trie_size(&state->node_trie), &vattr));
------------------
| | 656| 6.64k| do { \
| | 657| 6.64k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.64k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.64k]
| | ------------------
------------------
483| 6.64k| IGRAPH_CHECK(igraph_add_edges(state->g, &state->edgelist, &eattr));
------------------
| | 656| 6.64k| do { \
| | 657| 6.64k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.64k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.64k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.64k]
| | ------------------
------------------
484| 6.64k| IGRAPH_FINALLY_CLEAN(1); /* graph construction completed successfully */
485| |
486| 6.64k| igraph_attribute_record_list_destroy(&vattr);
487| 6.64k| igraph_attribute_record_list_destroy(&eattr);
488| 6.64k| igraph_attribute_record_list_destroy(&gattr);
489| 6.64k| IGRAPH_FINALLY_CLEAN(3);
490| |
491| 6.64k| return IGRAPH_SUCCESS;
492| 6.64k|}
graphml.c:igraph_i_xml_escape:
1371| 822k|static igraph_error_t igraph_i_xml_escape(const char *src, char **dest, const char *what) {
1372| 822k| igraph_int_t destlen = 0;
1373| 822k| const char *s;
1374| 822k| char *d;
1375| 822k| unsigned char ch;
1376| |
1377| 274M| for (s = src; *s; s++, destlen++) {
------------------
| Branch (1377:19): [True: 273M, False: 822k]
------------------
1378| 273M| ch = (unsigned char)(*s);
1379| 273M| if (ch == '&') {
------------------
| Branch (1379:13): [True: 1.86k, False: 273M]
------------------
1380| 1.86k| destlen += 4;
1381| 273M| } else if (ch == '<') {
------------------
| Branch (1381:20): [True: 108k, False: 273M]
------------------
1382| 108k| destlen += 3;
1383| 273M| } else if (ch == '>') {
------------------
| Branch (1383:20): [True: 22.4M, False: 251M]
------------------
1384| 22.4M| destlen += 3;
1385| 251M| } else if (ch == '"') {
------------------
| Branch (1385:20): [True: 14.1M, False: 236M]
------------------
1386| 14.1M| destlen += 5;
1387| 236M| } else if (ch == '\'') {
------------------
| Branch (1387:20): [True: 140M, False: 96.8M]
------------------
1388| 140M| destlen += 5;
1389| 140M| } else if (IS_FORBIDDEN_CONTROL_CHAR(ch)) {
------------------
| | 1363| 96.8M|#define IS_FORBIDDEN_CONTROL_CHAR(x) ((x) < ' ' && (x) != '\t' && (x) != '\r' && (x) != '\n')
| | ------------------
| | | Branch (1363:39): [True: 11.1M, False: 85.6M]
| | | Branch (1363:52): [True: 10.9M, False: 185k]
| | | Branch (1363:67): [True: 10.9M, False: 662]
| | | Branch (1363:82): [True: 0, False: 10.9M]
| | ------------------
------------------
1390| 0| IGRAPH_ERRORF("Forbidden control character 0x%02X found while writing %s to GraphML.",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
1391| 0| IGRAPH_EINVAL, ch, what);
1392| 0| }
1393| 273M| }
1394| 822k| *dest = IGRAPH_CALLOC(destlen + 1, char);
------------------
| | 33| 822k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.64M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 822k, False: 0]
| | | | | Branch (31:24): [True: 822k, False: 0]
| | | | | Branch (31:66): [True: 822k, False: 0]
| | | | ------------------
| | ------------------
------------------
1395| 822k| IGRAPH_CHECK_OOM(dest, "Insufficient memory to write GraphML file.");
------------------
| | 709| 822k| do { \
| | 710| 822k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 822k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 822k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 822k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 822k]
| | ------------------
------------------
1396| 274M| for (s = src, d = *dest; *s; s++, d++) {
------------------
| Branch (1396:30): [True: 273M, False: 822k]
------------------
1397| 273M| ch = (unsigned char)(*s);
1398| 273M| switch (ch) {
1399| 1.86k| case '&':
------------------
| Branch (1399:9): [True: 1.86k, False: 273M]
------------------
1400| 1.86k| strcpy(d, "&"); d += 4; break;
1401| 108k| case '<':
------------------
| Branch (1401:9): [True: 108k, False: 273M]
------------------
1402| 108k| strcpy(d, "<"); d += 3; break;
1403| 22.4M| case '>':
------------------
| Branch (1403:9): [True: 22.4M, False: 251M]
------------------
1404| 22.4M| strcpy(d, ">"); d += 3; break;
1405| 14.1M| case '"':
------------------
| Branch (1405:9): [True: 14.1M, False: 259M]
------------------
1406| 14.1M| strcpy(d, """); d += 5; break;
1407| 140M| case '\'':
------------------
| Branch (1407:9): [True: 140M, False: 133M]
------------------
1408| 140M| strcpy(d, "'"); d += 5; break;
1409| 96.8M| default:
------------------
| Branch (1409:9): [True: 96.8M, False: 176M]
------------------
1410| 96.8M| *d = ch;
1411| 273M| }
1412| 273M| }
1413| 822k| *d = 0;
1414| 822k| return IGRAPH_SUCCESS;
1415| 822k|}
igraph_write_graph_leda:
66| 3.34k| const char *edge_attr_name) {
67| 3.34k| igraph_int_t no_of_nodes = igraph_vcount(graph);
68| 3.34k| igraph_int_t no_of_edges = igraph_ecount(graph);
69| 3.34k| igraph_eit_t it;
70| 3.34k| igraph_int_t i = 0;
71| 3.34k| igraph_attribute_type_t vertex_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
72| 3.34k| igraph_attribute_type_t edge_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
73| 3.34k| igraph_int_t from, to, rev;
74| |
75| 3.34k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM), &it));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
76| 3.34k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
77| |
78| | /* Check if we have the vertex attribute */
79| 3.34k| if (vertex_attr_name &&
------------------
| Branch (79:9): [True: 3.34k, False: 0]
------------------
80| 3.34k| !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vertex_attr_name)) {
------------------
| Branch (80:9): [True: 2.87k, False: 465]
------------------
81| 2.87k| IGRAPH_WARNINGF("The vertex attribute '%s' does not exist. No vertex values will be written.",
------------------
| | 777| 2.87k| do { \
| | 778| 2.87k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.87k| __VA_ARGS__); \
| | 780| 2.87k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.87k]
| | ------------------
------------------
82| 2.87k| vertex_attr_name);
83| 2.87k| vertex_attr_name = NULL;
84| 2.87k| }
85| 3.34k| if (vertex_attr_name) {
------------------
| Branch (85:9): [True: 465, False: 2.87k]
------------------
86| 465| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &vertex_attr_type,
------------------
| | 656| 465| do { \
| | 657| 465| igraph_error_t igraph_i_ret = (expr); \
| | 658| 465| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 465| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 465]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 465| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 465]
| | ------------------
------------------
87| 465| IGRAPH_ATTRIBUTE_VERTEX, vertex_attr_name));
88| 465| if (vertex_attr_type != IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| Branch (88:13): [True: 446, False: 19]
------------------
89| 446| vertex_attr_type != IGRAPH_ATTRIBUTE_STRING &&
------------------
| Branch (89:13): [True: 29, False: 417]
------------------
90| 29| vertex_attr_type != IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (90:13): [True: 0, False: 29]
------------------
91| 0| IGRAPH_WARNINGF("The vertex attribute '%s' is not numeric, string or boolean. "
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
92| 0| "No vertex values will be written.",
93| 0| vertex_attr_name);
94| 0| vertex_attr_name = NULL; vertex_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
95| 0| }
96| 465| }
97| |
98| | /* Check if we have the edge attribute */
99| 3.34k| if (edge_attr_name &&
------------------
| Branch (99:9): [True: 3.34k, False: 0]
------------------
100| 3.34k| !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, edge_attr_name)) {
------------------
| Branch (100:9): [True: 3.10k, False: 232]
------------------
101| 3.10k| IGRAPH_WARNINGF("The edge attribute '%s' does not exist. No edge values will be written.",
------------------
| | 777| 3.10k| do { \
| | 778| 3.10k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.10k| __VA_ARGS__); \
| | 780| 3.10k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.10k]
| | ------------------
------------------
102| 3.10k| edge_attr_name);
103| 3.10k| edge_attr_name = NULL;
104| 3.10k| }
105| 3.34k| if (edge_attr_name) {
------------------
| Branch (105:9): [True: 232, False: 3.10k]
------------------
106| 232| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &edge_attr_type,
------------------
| | 656| 232| do { \
| | 657| 232| igraph_error_t igraph_i_ret = (expr); \
| | 658| 232| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 232| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 232]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 232| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 232]
| | ------------------
------------------
107| 232| IGRAPH_ATTRIBUTE_EDGE, edge_attr_name));
108| 232| if (edge_attr_type != IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| Branch (108:13): [True: 51, False: 181]
------------------
109| 51| edge_attr_type != IGRAPH_ATTRIBUTE_STRING &&
------------------
| Branch (109:13): [True: 1, False: 50]
------------------
110| 1| edge_attr_type != IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (110:13): [True: 0, False: 1]
------------------
111| 0| IGRAPH_WARNINGF("The edge attribute '%s' is not numeric, string or boolean. "
------------------
| | 777| 0| do { \
| | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 0| __VA_ARGS__); \
| | 780| 0| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 0]
| | ------------------
------------------
112| 0| "No edge values will be written.",
113| 0| edge_attr_name);
114| 0| edge_attr_name = NULL; edge_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
115| 0| }
116| 232| }
117| |
118| | /* Start writing header */
119| 3.34k| CHECK(fprintf(outstream, "LEDA.GRAPH\n"));
------------------
| | 33| 3.34k| do { \
| | 34| 3.34k| int ret=(cmd); \
| | 35| 3.34k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 3.34k]
| | ------------------
| | 36| 3.34k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.34k]
| | ------------------
------------------
120| |
121| 3.34k| switch (vertex_attr_type) {
122| 19| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (122:5): [True: 19, False: 3.32k]
------------------
123| 19| CHECK(fprintf(outstream, "double\n"));
------------------
| | 33| 19| do { \
| | 34| 19| int ret=(cmd); \
| | 35| 19| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 19]
| | ------------------
| | 36| 19| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 19]
| | ------------------
------------------
124| 19| break;
125| 417| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (125:5): [True: 417, False: 2.92k]
------------------
126| 417| CHECK(fprintf(outstream, "string\n"));
------------------
| | 33| 417| do { \
| | 34| 417| int ret=(cmd); \
| | 35| 417| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 417]
| | ------------------
| | 36| 417| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 417]
| | ------------------
------------------
127| 417| break;
128| 417| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (128:5): [True: 29, False: 3.31k]
------------------
129| 29| CHECK(fprintf(outstream, "bool\n"));
------------------
| | 33| 29| do { \
| | 34| 29| int ret=(cmd); \
| | 35| 29| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 29]
| | ------------------
| | 36| 29| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 29]
| | ------------------
------------------
130| 29| break;
131| 2.87k| default:
------------------
| Branch (131:5): [True: 2.87k, False: 465]
------------------
132| 2.87k| CHECK(fprintf(outstream, "void\n"));
------------------
| | 33| 2.87k| do { \
| | 34| 2.87k| int ret=(cmd); \
| | 35| 2.87k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 2.87k]
| | ------------------
| | 36| 2.87k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 2.87k]
| | ------------------
------------------
133| 3.34k| }
134| |
135| 3.34k| switch (edge_attr_type) {
136| 181| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (136:5): [True: 181, False: 3.15k]
------------------
137| 181| CHECK(fprintf(outstream, "double\n"));
------------------
| | 33| 181| do { \
| | 34| 181| int ret=(cmd); \
| | 35| 181| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 181]
| | ------------------
| | 36| 181| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 181]
| | ------------------
------------------
138| 181| break;
139| 181| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (139:5): [True: 50, False: 3.29k]
------------------
140| 50| CHECK(fprintf(outstream, "string\n"));
------------------
| | 33| 50| do { \
| | 34| 50| int ret=(cmd); \
| | 35| 50| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 50]
| | ------------------
| | 36| 50| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 50]
| | ------------------
------------------
141| 50| break;
142| 50| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (142:5): [True: 1, False: 3.33k]
------------------
143| 1| CHECK(fprintf(outstream, "bool\n"));
------------------
| | 33| 1| do { \
| | 34| 1| int ret=(cmd); \
| | 35| 1| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 1]
| | ------------------
| | 36| 1| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 1]
| | ------------------
------------------
144| 1| break;
145| 3.10k| default:
------------------
| Branch (145:5): [True: 3.10k, False: 232]
------------------
146| 3.10k| CHECK(fprintf(outstream, "void\n"));
------------------
| | 33| 3.10k| do { \
| | 34| 3.10k| int ret=(cmd); \
| | 35| 3.10k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 3.10k]
| | ------------------
| | 36| 3.10k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.10k]
| | ------------------
------------------
147| 3.34k| }
148| |
149| 3.34k| CHECK(fprintf(outstream, "%d\n", (igraph_is_directed(graph) ? -1 : -2)));
------------------
| | 33| 3.34k| do { \
| | 34| 6.68k| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 137, False: 3.20k]
| | ------------------
| | 35| 3.34k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 3.34k]
| | ------------------
| | 36| 3.34k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.34k]
| | ------------------
------------------
150| |
151| | /* Start writing vertices */
152| 3.34k| CHECK(fprintf(outstream, "# Vertices\n"));
------------------
| | 33| 3.34k| do { \
| | 34| 3.34k| int ret=(cmd); \
| | 35| 3.34k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 3.34k]
| | ------------------
| | 36| 3.34k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.34k]
| | ------------------
------------------
153| 3.34k| CHECK(fprintf(outstream, "%" IGRAPH_PRId "\n", no_of_nodes));
------------------
| | 33| 3.34k| do { \
| | 34| 3.34k| int ret=(cmd); \
| | 35| 3.34k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 3.34k]
| | ------------------
| | 36| 3.34k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.34k]
| | ------------------
------------------
154| |
155| 3.34k| if (vertex_attr_type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (155:9): [True: 19, False: 3.32k]
------------------
156| | /* Vertices with numeric attributes */
157| 19| igraph_vector_t values;
158| |
159| 19| IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 104| 19| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 19| do { \
| | | | 657| 19| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 19| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 19| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 19]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 19| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 19]
| | | | ------------------
| | ------------------
| | 105| 19| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 19| do { \
| | | | 604| 19| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 19| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 19| * incorrect destructor function with the pointer */ \
| | | | 607| 19| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 19]
| | | | ------------------
| | | | 608| 19| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 19| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 19]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 19]
| | ------------------
------------------
160| 19| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 656| 19| do { \
| | 657| 19| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19]
| | ------------------
------------------
161| 19| graph, vertex_attr_name, igraph_vss_all(), &values));
162| |
163| 342| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (163:21): [True: 323, False: 19]
------------------
164| 323| CHECK(fprintf(outstream, "|{"));
------------------
| | 33| 323| do { \
| | 34| 323| int ret=(cmd); \
| | 35| 323| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 323]
| | ------------------
| | 36| 323| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 323]
| | ------------------
------------------
165| 323| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(values)[i]));
------------------
| | 33| 323| do { \
| | 34| 323| int ret=(cmd); \
| | 35| 323| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 323]
| | ------------------
| | 36| 323| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 323]
| | ------------------
------------------
166| 323| CHECK(fprintf(outstream, "}|\n"));
------------------
| | 33| 323| do { \
| | 34| 323| int ret=(cmd); \
| | 35| 323| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 323]
| | ------------------
| | 36| 323| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 323]
| | ------------------
------------------
167| 323| }
168| |
169| 19| igraph_vector_destroy(&values);
170| 19| IGRAPH_FINALLY_CLEAN(1);
171| 3.32k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (171:16): [True: 417, False: 2.90k]
------------------
172| | /* Vertices with string attributes */
173| 417| igraph_strvector_t values;
174| |
175| 417| IGRAPH_CHECK(igraph_strvector_init(&values, no_of_nodes));
------------------
| | 656| 417| do { \
| | 657| 417| igraph_error_t igraph_i_ret = (expr); \
| | 658| 417| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 417| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 417| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 417]
| | ------------------
------------------
176| 417| IGRAPH_FINALLY(igraph_strvector_destroy, &values);
------------------
| | 603| 417| do { \
| | 604| 417| /* the following branch makes the compiler check the compatibility of \
| | 605| 417| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 417| * incorrect destructor function with the pointer */ \
| | 607| 417| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 417]
| | ------------------
| | 608| 417| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 417| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 417]
| | ------------------
------------------
177| |
178| 417| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 417| do { \
| | 657| 417| igraph_error_t igraph_i_ret = (expr); \
| | 658| 417| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 417| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 417| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 417]
| | ------------------
------------------
179| 417| graph, vertex_attr_name, igraph_vss_all(), &values));
180| |
181| 7.18k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (181:21): [True: 6.80k, False: 380]
------------------
182| 6.80k| const char *str = igraph_strvector_get(&values, i);
183| 6.80k| if (strchr(str, '\n') != 0) {
------------------
| Branch (183:17): [True: 37, False: 6.77k]
------------------
184| 37| IGRAPH_ERROR("Vertex attribute values cannot contain newline characters.",
------------------
| | 426| 37| do { \
| | 427| 37| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 37| return igraph_errno ; \
| | 429| 37| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
185| 37| IGRAPH_EINVAL);
186| 37| }
187| 6.77k| CHECK(fprintf(outstream, "|{%s}|\n", str));
------------------
| | 33| 6.77k| do { \
| | 34| 6.77k| int ret=(cmd); \
| | 35| 6.77k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 6.77k]
| | ------------------
| | 36| 6.77k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 6.77k]
| | ------------------
------------------
188| 6.77k| }
189| |
190| 380| igraph_strvector_destroy(&values);
191| 380| IGRAPH_FINALLY_CLEAN(1);
192| 2.90k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (192:16): [True: 29, False: 2.87k]
------------------
193| | /* Vertices with boolean attributes */
194| 29| igraph_vector_bool_t values;
195| |
196| 29| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 109| 29| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 29| do { \
| | | | 657| 29| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 29| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 29| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 29]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 29| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 29]
| | | | ------------------
| | ------------------
| | 110| 29| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 29| do { \
| | | | 604| 29| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 29| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 29| * incorrect destructor function with the pointer */ \
| | | | 607| 29| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 29]
| | | | ------------------
| | | | 608| 29| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 29| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 29]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 29]
| | ------------------
------------------
197| 29| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(
------------------
| | 656| 29| do { \
| | 657| 29| igraph_error_t igraph_i_ret = (expr); \
| | 658| 29| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 29| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 29]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 29| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 29]
| | ------------------
------------------
198| 29| graph, vertex_attr_name, igraph_vss_all(), &values));
199| |
200| 247| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (200:21): [True: 218, False: 29]
------------------
201| 218| CHECK(fprintf(outstream, "|{%s|}\n", VECTOR(values)[i] ? "true" : "false"));
------------------
| | 33| 218| do { \
| | 34| 436| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 0, False: 218]
| | ------------------
| | 35| 218| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 218]
| | ------------------
| | 36| 218| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 218]
| | ------------------
------------------
202| 218| }
203| |
204| 29| igraph_vector_bool_destroy(&values);
205| 29| IGRAPH_FINALLY_CLEAN(1);
206| 2.87k| } else {
207| | /* Vertices with no attributes */
208| 28.1k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (208:21): [True: 25.3k, False: 2.87k]
------------------
209| 25.3k| CHECK(fprintf(outstream, "|{}|\n"));
------------------
| | 33| 25.3k| do { \
| | 34| 25.3k| int ret=(cmd); \
| | 35| 25.3k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 25.3k]
| | ------------------
| | 36| 25.3k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 25.3k]
| | ------------------
------------------
210| 25.3k| }
211| 2.87k| }
212| |
213| 3.30k| CHECK(fprintf(outstream, "# Edges\n"));
------------------
| | 33| 3.30k| do { \
| | 34| 3.30k| int ret=(cmd); \
| | 35| 3.30k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 3.30k]
| | ------------------
| | 36| 3.30k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.30k]
| | ------------------
------------------
214| 3.30k| CHECK(fprintf(outstream, "%" IGRAPH_PRId "\n", no_of_edges));
------------------
| | 33| 3.30k| do { \
| | 34| 3.30k| int ret=(cmd); \
| | 35| 3.30k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 3.30k]
| | ------------------
| | 36| 3.30k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.30k]
| | ------------------
------------------
215| |
216| 3.30k| if (edge_attr_type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (216:9): [True: 180, False: 3.12k]
------------------
217| | /* Edges with numeric attributes */
218| 180| igraph_vector_t values;
219| 180| IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 104| 180| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 180| do { \
| | | | 657| 180| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 180| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 180| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 180]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 180| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 180]
| | | | ------------------
| | ------------------
| | 105| 180| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 180| do { \
| | | | 604| 180| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 180| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 180| * incorrect destructor function with the pointer */ \
| | | | 607| 180| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 180]
| | | | ------------------
| | | | 608| 180| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 180| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 180]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 180]
| | ------------------
------------------
220| 180| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 180| do { \
| | 657| 180| igraph_error_t igraph_i_ret = (expr); \
| | 658| 180| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 180| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 180]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 180| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 180]
| | ------------------
------------------
221| 180| graph, edge_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
222| 94.9k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 94.9k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (222:16): [True: 94.7k, False: 180]
------------------
223| 94.7k| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 94.7k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 94.7k]
| | ------------------
| | 406| 94.7k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 94.7k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
224| 94.7k| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 94.7k| do { \
| | 657| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 94.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 94.7k]
| | ------------------
------------------
225| 94.7k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 94.7k| do { \
| | 657| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 94.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 94.7k]
| | ------------------
------------------
226| 94.7k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 94.7k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 94.7k]
| | ------------------
| | 406| 94.7k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 94.7k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (226:17): [True: 3.15k, False: 91.5k]
------------------
227| 3.15k| rev = -1;
228| 3.15k| }
229| 94.7k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{",
------------------
| | 33| 94.7k| do { \
| | 34| 94.7k| int ret=(cmd); \
| | 35| 94.7k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 94.7k]
| | ------------------
| | 36| 94.7k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 94.7k]
| | ------------------
------------------
230| 94.7k| from + 1, to + 1,
231| 94.7k| rev + 1));
232| 94.7k| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(values)[eid]));
------------------
| | 33| 94.7k| do { \
| | 34| 94.7k| int ret=(cmd); \
| | 35| 94.7k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 94.7k]
| | ------------------
| | 36| 94.7k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 94.7k]
| | ------------------
------------------
233| 94.7k| CHECK(fprintf(outstream, "}|\n"));
------------------
| | 33| 94.7k| do { \
| | 34| 94.7k| int ret=(cmd); \
| | 35| 94.7k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 94.7k]
| | ------------------
| | 36| 94.7k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 94.7k]
| | ------------------
------------------
234| 94.7k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 94.7k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
235| 94.7k| }
236| 180| igraph_vector_destroy(&values);
237| 180| IGRAPH_FINALLY_CLEAN(1);
238| 3.12k| } else if (edge_attr_type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (238:16): [True: 50, False: 3.07k]
------------------
239| | /* Edges with string attributes */
240| 50| igraph_strvector_t values;
241| 50| IGRAPH_CHECK(igraph_strvector_init(&values, no_of_nodes));
------------------
| | 656| 50| do { \
| | 657| 50| igraph_error_t igraph_i_ret = (expr); \
| | 658| 50| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 50| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 50]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 50| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 50]
| | ------------------
------------------
242| 50| IGRAPH_FINALLY(igraph_strvector_destroy, &values);
------------------
| | 603| 50| do { \
| | 604| 50| /* the following branch makes the compiler check the compatibility of \
| | 605| 50| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 50| * incorrect destructor function with the pointer */ \
| | 607| 50| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 50]
| | ------------------
| | 608| 50| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 50| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 50]
| | ------------------
------------------
243| 50| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(
------------------
| | 656| 50| do { \
| | 657| 50| igraph_error_t igraph_i_ret = (expr); \
| | 658| 50| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 50| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 50]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 50| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 50]
| | ------------------
------------------
244| 50| graph, edge_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
245| 44.9k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 44.9k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (245:16): [True: 44.9k, False: 49]
------------------
246| 44.9k| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 44.9k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 44.9k]
| | ------------------
| | 406| 44.9k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 44.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
247| 44.9k| const char *str = igraph_strvector_get(&values, eid);
248| 44.9k| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 44.9k| do { \
| | 657| 44.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 44.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 44.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 44.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 44.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 44.9k]
| | ------------------
------------------
249| 44.9k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 44.9k| do { \
| | 657| 44.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 44.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 44.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 44.9k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 44.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 44.9k]
| | ------------------
------------------
250| 44.9k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 44.9k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 44.9k]
| | ------------------
| | 406| 44.9k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 44.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (250:17): [True: 662, False: 44.2k]
------------------
251| 662| rev = -1;
252| 662| }
253| 44.9k| if (strchr(str, '\n') != 0) {
------------------
| Branch (253:17): [True: 1, False: 44.9k]
------------------
254| 1| IGRAPH_ERROR("Edge attribute values cannot contain newline characters.",
------------------
| | 426| 1| do { \
| | 427| 1| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 1| return igraph_errno ; \
| | 429| 1| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
255| 1| IGRAPH_EINVAL);
256| 1| }
257| 44.9k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{%s}|\n",
------------------
| | 33| 44.9k| do { \
| | 34| 44.9k| int ret=(cmd); \
| | 35| 44.9k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 44.9k]
| | ------------------
| | 36| 44.9k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 44.9k]
| | ------------------
------------------
258| 44.9k| from + 1, to + 1,
259| 44.9k| rev + 1, str));
260| 44.9k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 44.9k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
261| 44.9k| }
262| 49| igraph_strvector_destroy(&values);
263| 49| IGRAPH_FINALLY_CLEAN(1);
264| 3.07k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (264:16): [True: 28, False: 3.04k]
------------------
265| | /* Edges with boolean attributes */
266| 28| igraph_vector_bool_t values;
267| |
268| 28| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&values, no_of_edges);
------------------
| | 109| 28| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 28| do { \
| | | | 657| 28| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 28| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 28| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 28]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 28| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 28]
| | | | ------------------
| | ------------------
| | 110| 28| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 28| do { \
| | | | 604| 28| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 28| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 28| * incorrect destructor function with the pointer */ \
| | | | 607| 28| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 28]
| | | | ------------------
| | | | 608| 28| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 28| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 28]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 28]
| | ------------------
------------------
269| 28| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(
------------------
| | 656| 28| do { \
| | 657| 28| igraph_error_t igraph_i_ret = (expr); \
| | 658| 28| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 28| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 10, False: 18]
| | | | ------------------
| | ------------------
| | 659| 10| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 10| do { \
| | | | 427| 10| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 10| return igraph_errno ; \
| | | | 429| 10| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 10| } \
| | 661| 28| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 18]
| | ------------------
------------------
270| 28| graph, vertex_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
271| |
272| 185| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 185|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (272:16): [True: 167, False: 18]
------------------
273| 167| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 167| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 167]
| | ------------------
| | 406| 167| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 167|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
274| 167| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 167| do { \
| | 657| 167| igraph_error_t igraph_i_ret = (expr); \
| | 658| 167| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 167| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 167]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 167| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 167]
| | ------------------
------------------
275| 167| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 167| do { \
| | 657| 167| igraph_error_t igraph_i_ret = (expr); \
| | 658| 167| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 167| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 167]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 167| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 167]
| | ------------------
------------------
276| 167| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 167| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 167]
| | ------------------
| | 406| 167| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 167|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (276:17): [True: 91, False: 76]
------------------
277| 91| rev = -1;
278| 91| }
279| 167| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{%s}|\n",
------------------
| | 33| 167| do { \
| | 34| 334| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 0, False: 167]
| | ------------------
| | 35| 167| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 167]
| | ------------------
| | 36| 167| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 167]
| | ------------------
------------------
280| 167| from + 1, to + 1,
281| 167| rev + 1,
282| 167| VECTOR(values)[eid] ? "true" : "false"));
283| 167| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 167|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
284| 167| }
285| |
286| 18| igraph_vector_bool_destroy(&values);
287| 18| IGRAPH_FINALLY_CLEAN(1);
288| 3.04k| } else {
289| | /* Edges with no attributes */
290| 207k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 207k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (290:16): [True: 204k, False: 3.04k]
------------------
291| 204k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 204k| do { \
| | 657| 408k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 0, False: 204k]
| | ------------------
| | 658| 204k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 204k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 204k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 204k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 204k]
| | ------------------
------------------
292| 204k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 204k| do { \
| | 657| 204k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 204k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 204k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 204k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 204k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 204k]
| | ------------------
------------------
293| 204k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 204k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 204k]
| | ------------------
| | 406| 204k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 204k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (293:17): [True: 16.9k, False: 187k]
------------------
294| 16.9k| rev = -1;
295| 16.9k| }
296| 204k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{}|\n",
------------------
| | 33| 204k| do { \
| | 34| 204k| int ret=(cmd); \
| | 35| 204k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 204k]
| | ------------------
| | 36| 204k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 204k]
| | ------------------
------------------
297| 204k| from + 1, to + 1,
298| 204k| rev + 1));
299| 204k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 204k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
300| 204k| }
301| 3.04k| }
302| |
303| 3.29k| igraph_eit_destroy(&it);
304| 3.29k| IGRAPH_FINALLY_CLEAN(1);
305| |
306| 3.29k| return IGRAPH_SUCCESS;
307| 3.30k|}
igraph_read_graph_lgl:
107| 3.19k| igraph_bool_t directed) {
108| |
109| 3.19k| igraph_vector_int_t edges = IGRAPH_VECTOR_NULL;
------------------
| | 99| 3.19k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
------------------
110| 3.19k| igraph_vector_t ws = IGRAPH_VECTOR_NULL;
------------------
| | 99| 3.19k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
------------------
111| 3.19k| igraph_trie_t trie = IGRAPH_TRIE_NULL;
------------------
| | 52| 3.19k| { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 60| 3.19k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 44| 3.19k|#define IGRAPH_VECTOR_PTR_NULL { 0,0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 99| 3.19k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
| | ------------------
| | 53| 3.19k| 0, 0, IGRAPH_STRVECTOR_NULL }
| | ------------------
| | | | 60| 3.19k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
------------------
112| 3.19k| igraph_attribute_record_list_t name, weight;
113| 3.19k| igraph_attribute_record_list_t *pname = NULL, *pweight = NULL;
114| 3.19k| igraph_attribute_record_t *namerec, *weightrec;
115| 3.19k| const char *namestr = "name", *weightstr = "weight";
116| 3.19k| igraph_i_lgl_parsedata_t context;
117| |
118| 3.19k| IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);
------------------
| | 104| 3.19k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.19k| do { \
| | | | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.19k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.19k]
| | | | ------------------
| | ------------------
| | 105| 3.19k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.19k| do { \
| | | | 604| 3.19k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.19k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.19k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.19k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.19k]
| | | | ------------------
| | | | 608| 3.19k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.19k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.19k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.19k]
| | ------------------
------------------
119| 3.19k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0);
------------------
| | 119| 3.19k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.19k| do { \
| | | | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.19k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.19k]
| | | | ------------------
| | ------------------
| | 120| 3.19k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.19k| do { \
| | | | 604| 3.19k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.19k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.19k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.19k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.19k]
| | | | ------------------
| | | | 608| 3.19k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.19k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.19k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.19k]
| | ------------------
------------------
120| 3.19k| IGRAPH_TRIE_INIT_FINALLY(&trie, names);
------------------
| | 55| 3.19k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.19k| do { \
| | | | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.19k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.19k]
| | | | ------------------
| | ------------------
| | 56| 3.19k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.19k| do { \
| | | | 604| 3.19k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.19k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.19k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.19k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.19k]
| | | | ------------------
| | | | 608| 3.19k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.19k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.19k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.19k]
| | ------------------
------------------
121| |
122| 3.19k| context.has_weights = false;
123| 3.19k| context.vector = &edges;
124| 3.19k| context.weights = &ws;
125| 3.19k| context.trie = ≜
126| 3.19k| context.errmsg[0] = '\0';
127| 3.19k| context.igraph_errno = IGRAPH_SUCCESS;
128| |
129| 3.19k| igraph_lgl_yylex_init_extra(&context, &context.scanner);
130| 3.19k| IGRAPH_FINALLY(igraph_lgl_yylex_destroy_wrapper, context.scanner);
------------------
| | 603| 3.19k| do { \
| | 604| 3.19k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.19k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.19k| * incorrect destructor function with the pointer */ \
| | 607| 3.19k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.19k]
| | ------------------
| | 608| 3.19k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.19k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.19k]
| | ------------------
------------------
131| |
132| 3.19k| igraph_lgl_yyset_in(instream, context.scanner);
133| |
134| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */
135| 3.19k| IGRAPH_FINALLY_ENTER();
136| 3.19k| int err = igraph_lgl_yyparse(&context);
137| 3.19k| IGRAPH_FINALLY_EXIT();
138| 3.19k| switch (err) {
139| 3.19k| case 0: /* success */
------------------
| Branch (139:5): [True: 3.19k, False: 0]
------------------
140| 3.19k| break;
141| 0| case 1: /* parse error */
------------------
| Branch (141:5): [True: 0, False: 3.19k]
------------------
142| 0| if (context.errmsg[0] != '\0') {
------------------
| Branch (142:13): [True: 0, False: 0]
------------------
143| 0| IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
144| 0| } else if (context.igraph_errno != IGRAPH_SUCCESS) {
------------------
| Branch (144:20): [True: 0, False: 0]
------------------
145| 0| IGRAPH_ERROR("", context.igraph_errno);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
146| 0| } else {
147| 0| IGRAPH_ERROR("Cannot read LGL file.", IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
148| 0| }
149| 0| break;
150| 0| case 2: /* out of memory */
------------------
| Branch (150:5): [True: 0, False: 3.19k]
------------------
151| 0| IGRAPH_ERROR("Cannot read LGL file.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
152| 0| break;
153| 0| default: /* must never reach here */
------------------
| Branch (153:5): [True: 0, False: 3.19k]
------------------
154| | /* Hint: This will usually be triggered if an IGRAPH_CHECK() is used in a Bison
155| | * action instead of an IGRAPH_YY_CHECK(), resulting in an igraph errno being
156| | * returned in place of a Bison error code.
157| | * TODO: What if future Bison versions introduce error codes other than 0, 1 and 2?
158| | */
159| 0| IGRAPH_FATALF("Parser returned unexpected error code (%d) when reading LGL file.", err);
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
160| 3.19k| }
161| |
162| | /* Prepare attributes if needed */
163| 3.19k| if (names) {
------------------
| Branch (163:9): [True: 3.19k, False: 0]
------------------
164| 3.19k| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1));
------------------
| | 656| 3.19k| do { \
| | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.19k]
| | ------------------
------------------
165| 3.19k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name);
------------------
| | 603| 3.19k| do { \
| | 604| 3.19k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.19k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.19k| * incorrect destructor function with the pointer */ \
| | 607| 3.19k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.19k]
| | ------------------
| | 608| 3.19k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.19k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.19k]
| | ------------------
------------------
166| |
167| 3.19k| namerec = igraph_attribute_record_list_get_ptr(&name, 0);
168| 3.19k| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr));
------------------
| | 656| 3.19k| do { \
| | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.19k]
| | ------------------
------------------
169| 3.19k| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.19k| do { \
| | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.19k]
| | ------------------
------------------
170| 3.19k| IGRAPH_CHECK(igraph_strvector_update(
------------------
| | 656| 3.19k| do { \
| | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.19k]
| | ------------------
------------------
171| 3.19k| namerec->value.as_strvector, igraph_i_trie_borrow_keys(context.trie))
172| 3.19k| );
173| |
174| 3.19k| pname = &name;
175| 3.19k| }
176| |
177| 3.19k| if (weights == IGRAPH_ADD_WEIGHTS_YES ||
------------------
| Branch (177:9): [True: 0, False: 3.19k]
------------------
178| 3.19k| (weights == IGRAPH_ADD_WEIGHTS_IF_PRESENT && context.has_weights)) {
------------------
| Branch (178:10): [True: 3.19k, False: 0]
| Branch (178:54): [True: 162, False: 3.03k]
------------------
179| 162| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1));
------------------
| | 656| 162| do { \
| | 657| 162| igraph_error_t igraph_i_ret = (expr); \
| | 658| 162| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 162| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 162]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 162| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 162]
| | ------------------
------------------
180| 162| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight);
------------------
| | 603| 162| do { \
| | 604| 162| /* the following branch makes the compiler check the compatibility of \
| | 605| 162| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 162| * incorrect destructor function with the pointer */ \
| | 607| 162| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 162]
| | ------------------
| | 608| 162| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 162| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 162]
| | ------------------
------------------
181| |
182| 162| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0);
183| 162| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr));
------------------
| | 656| 162| do { \
| | 657| 162| igraph_error_t igraph_i_ret = (expr); \
| | 658| 162| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 162| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 162]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 162| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 162]
| | ------------------
------------------
184| 162| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC));
------------------
| | 656| 162| do { \
| | 657| 162| igraph_error_t igraph_i_ret = (expr); \
| | 658| 162| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 162| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 162]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 162| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 162]
| | ------------------
------------------
185| 162| igraph_vector_swap(weightrec->value.as_vector, context.weights);
186| |
187| 162| pweight = &weight;
188| 162| }
189| |
190| | /* Create graph */
191| 3.19k| IGRAPH_CHECK(igraph_empty(graph, 0, directed));
------------------
| | 656| 3.19k| do { \
| | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.19k]
| | ------------------
------------------
192| 3.19k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.19k| do { \
| | 604| 3.19k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.19k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.19k| * incorrect destructor function with the pointer */ \
| | 607| 3.19k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.19k]
| | ------------------
| | 608| 3.19k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.19k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.19k]
| | ------------------
------------------
193| 3.19k| IGRAPH_CHECK(igraph_add_vertices(graph, igraph_trie_size(&trie), pname));
------------------
| | 656| 3.19k| do { \
| | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.19k]
| | ------------------
------------------
194| 3.19k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));
------------------
| | 656| 3.19k| do { \
| | 657| 3.19k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.19k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.19k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.19k]
| | ------------------
------------------
195| |
196| 3.19k| if (pweight) {
------------------
| Branch (196:9): [True: 162, False: 3.03k]
------------------
197| 162| igraph_attribute_record_list_destroy(pweight);
198| 162| IGRAPH_FINALLY_CLEAN(1);
199| 162| }
200| 3.19k| if (pname) {
------------------
| Branch (200:9): [True: 3.19k, False: 0]
------------------
201| 3.19k| igraph_attribute_record_list_destroy(pname);
202| 3.19k| IGRAPH_FINALLY_CLEAN(1);
203| 3.19k| }
204| 3.19k| igraph_trie_destroy(&trie);
205| 3.19k| igraph_vector_int_destroy(&edges);
206| 3.19k| igraph_vector_destroy(&ws);
207| 3.19k| igraph_lgl_yylex_destroy(context.scanner);
208| 3.19k| IGRAPH_FINALLY_CLEAN(5);
209| |
210| 3.19k| return IGRAPH_SUCCESS;
211| 3.19k|}
igraph_write_graph_lgl:
271| 3.34k| igraph_bool_t isolates) {
272| 3.34k| igraph_eit_t it;
273| 3.34k| igraph_int_t actvertex = -1;
274| 3.34k| igraph_attribute_type_t nametype, weighttype;
275| 3.34k| const igraph_int_t vcount = igraph_vcount(graph), ecount = igraph_ecount(graph);
276| |
277| 3.34k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM),
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
278| 3.34k| &it));
279| 3.34k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
280| |
281| | /* Check if we have the names attribute */
282| 3.34k| if (names && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
------------------
| Branch (282:9): [True: 3.34k, False: 0]
| Branch (282:18): [True: 2.87k, False: 465]
------------------
283| 3.34k| names)) {
284| 2.87k| IGRAPH_WARNINGF("Names attribute '%s' does not exist.", names);
------------------
| | 777| 2.87k| do { \
| | 778| 2.87k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.87k| __VA_ARGS__); \
| | 780| 2.87k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.87k]
| | ------------------
------------------
285| 2.87k| names = NULL;
286| 2.87k| }
287| 3.34k| if (names) {
------------------
| Branch (287:9): [True: 465, False: 2.87k]
------------------
288| 465| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &nametype,
------------------
| | 656| 465| do { \
| | 657| 465| igraph_error_t igraph_i_ret = (expr); \
| | 658| 465| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 465| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 465]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 465| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 465]
| | ------------------
------------------
289| 465| IGRAPH_ATTRIBUTE_VERTEX, names));
290| 465| if (nametype != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (290:13): [True: 48, False: 417]
------------------
291| 48| IGRAPH_WARNINGF("Ignoring names attribute '%s', unknown attribute type.", names);
------------------
| | 777| 48| do { \
| | 778| 48| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 48| __VA_ARGS__); \
| | 780| 48| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 48]
| | ------------------
------------------
292| 48| names = NULL;
293| 48| }
294| 465| }
295| |
296| | /* Check the weights as well */
297| 3.34k| if (weights && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, weights)) {
------------------
| Branch (297:9): [True: 3.34k, False: 0]
| Branch (297:20): [True: 3.10k, False: 232]
------------------
298| 3.10k| IGRAPH_WARNINGF("Weights attribute '%s' does not exist.", weights);
------------------
| | 777| 3.10k| do { \
| | 778| 3.10k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.10k| __VA_ARGS__); \
| | 780| 3.10k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.10k]
| | ------------------
------------------
299| 3.10k| weights = NULL;
300| 3.10k| }
301| 3.34k| if (weights) {
------------------
| Branch (301:9): [True: 232, False: 3.10k]
------------------
302| 232| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &weighttype,
------------------
| | 656| 232| do { \
| | 657| 232| igraph_error_t igraph_i_ret = (expr); \
| | 658| 232| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 232| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 232]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 232| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 232]
| | ------------------
------------------
303| 232| IGRAPH_ATTRIBUTE_EDGE, weights));
304| 232| if (weighttype != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (304:13): [True: 51, False: 181]
------------------
305| 51| IGRAPH_WARNINGF("Ignoring weights attribute '%s', unknown attribute type.", weights);
------------------
| | 777| 51| do { \
| | 778| 51| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 51| __VA_ARGS__); \
| | 780| 51| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 51]
| | ------------------
------------------
306| 51| weights = NULL;
307| 51| }
308| 232| }
309| |
310| 3.34k| if (names == NULL && weights == NULL) {
------------------
| Branch (310:9): [True: 2.92k, False: 417]
| Branch (310:26): [True: 2.81k, False: 108]
------------------
311| | /* No names, no weights */
312| 236k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 236k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (312:16): [True: 233k, False: 2.81k]
------------------
313| 233k| igraph_int_t from, to;
314| 233k| int ret;
315| |
316| 233k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 233k| do { \
| | 657| 466k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 0, False: 233k]
| | ------------------
| | 658| 233k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 233k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 233k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 233k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 233k]
| | ------------------
------------------
317| 233k| if (from == actvertex) {
------------------
| Branch (317:17): [True: 223k, False: 9.79k]
------------------
318| 223k| ret = fprintf(outstream, "%" IGRAPH_PRId "\n", to);
319| 223k| } else {
320| 9.79k| actvertex = from;
321| 9.79k| ret = fprintf(outstream, "# %" IGRAPH_PRId "\n%" IGRAPH_PRId "\n", from, to);
322| 9.79k| }
323| 233k| if (ret < 0) {
------------------
| Branch (323:17): [True: 0, False: 233k]
------------------
324| 0| IGRAPH_ERROR("Writing LGL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
325| 0| }
326| 233k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 233k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
327| 233k| }
328| 2.81k| } else if (weights == NULL) {
------------------
| Branch (328:16): [True: 344, False: 181]
------------------
329| | /* No weights but use names */
330| 344| igraph_strvector_t nvec;
331| 344| IGRAPH_STRVECTOR_INIT_FINALLY(&nvec, vcount);
------------------
| | 62| 344| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 344| do { \
| | | | 657| 344| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 344]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 344| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 344]
| | | | ------------------
| | ------------------
| | 63| 344| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 344| do { \
| | | | 604| 344| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 344| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 344| * incorrect destructor function with the pointer */ \
| | | | 607| 344| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 344]
| | | | ------------------
| | | | 608| 344| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 344| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 344]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 344]
| | ------------------
------------------
332| 344| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 344| do { \
| | 657| 344| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344]
| | ------------------
------------------
333| 344| igraph_vss_all(),
334| 344| &nvec));
335| 14.2k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 14.2k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (335:16): [True: 14.0k, False: 210]
------------------
336| 14.0k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 14.0k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 14.0k]
| | ------------------
| | 406| 14.0k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
337| 14.0k| igraph_int_t from, to;
338| 14.0k| int ret = 0;
339| 14.0k| const char *str1, *str2;
340| |
341| 14.0k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 14.0k| do { \
| | 657| 14.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.0k]
| | ------------------
------------------
342| 14.0k| str2 = igraph_strvector_get(&nvec, to);
343| 14.0k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 14.0k| do { \
| | 657| 14.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 130, False: 13.9k]
| | | | ------------------
| | ------------------
| | 659| 130| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 130| do { \
| | | | 427| 130| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 130| return igraph_errno ; \
| | | | 429| 130| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 130| } \
| | 661| 14.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.9k]
| | ------------------
------------------
344| |
345| 13.9k| if (from == actvertex) {
------------------
| Branch (345:17): [True: 12.2k, False: 1.71k]
------------------
346| 12.2k| ret = fprintf(outstream, "%s\n", str2);
347| 12.2k| } else {
348| 1.71k| actvertex = from;
349| 1.71k| str1 = igraph_strvector_get(&nvec, from);
350| 1.71k| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 1.71k| do { \
| | 657| 1.71k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 4, False: 1.71k]
| | | | ------------------
| | ------------------
| | 659| 4| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 4| do { \
| | | | 427| 4| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 4| return igraph_errno ; \
| | | | 429| 4| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 4| } \
| | 661| 1.71k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.71k]
| | ------------------
------------------
351| 1.71k| ret = fprintf(outstream, "# %s\n%s\n", str1, str2);
352| 1.71k| }
353| 13.9k| if (ret < 0) {
------------------
| Branch (353:17): [True: 0, False: 13.9k]
------------------
354| 0| IGRAPH_ERROR("Writing LGL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
355| 0| }
356| 13.9k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 13.9k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
357| 13.9k| }
358| 210| igraph_strvector_destroy(&nvec);
359| 210| IGRAPH_FINALLY_CLEAN(1);
360| 210| } else if (names == NULL) {
------------------
| Branch (360:16): [True: 108, False: 73]
------------------
361| | /* No names but weights */
362| 108| igraph_vector_t wvec;
363| 108| IGRAPH_VECTOR_INIT_FINALLY(&wvec, ecount);
------------------
| | 104| 108| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 108| do { \
| | | | 657| 108| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 108| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 108| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 108]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 108| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 108]
| | | | ------------------
| | ------------------
| | 105| 108| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 108| do { \
| | | | 604| 108| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 108| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 108| * incorrect destructor function with the pointer */ \
| | | | 607| 108| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 108]
| | | | ------------------
| | | | 608| 108| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 108| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 108]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 108]
| | ------------------
------------------
364| 108| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 108| do { \
| | 657| 108| igraph_error_t igraph_i_ret = (expr); \
| | 658| 108| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 108| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 108]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 108| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 108]
| | ------------------
------------------
365| 108| igraph_ess_all(IGRAPH_EDGEORDER_ID),
366| 108| &wvec));
367| 75.1k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 75.1k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (367:16): [True: 75.0k, False: 108]
------------------
368| 75.0k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 75.0k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 75.0k]
| | ------------------
| | 406| 75.0k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 75.0k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
369| 75.0k| igraph_int_t from, to;
370| 75.0k| int ret1, ret2, ret3;
371| |
372| 75.0k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 75.0k| do { \
| | 657| 75.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 75.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 75.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 75.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 75.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 75.0k]
| | ------------------
------------------
373| 75.0k| if (from == actvertex) {
------------------
| Branch (373:17): [True: 73.9k, False: 1.10k]
------------------
374| 73.9k| ret1 = fprintf(outstream, "%" IGRAPH_PRId " ", to);
375| 73.9k| } else {
376| 1.10k| actvertex = from;
377| 1.10k| ret1 = fprintf(outstream, "# %" IGRAPH_PRId "\n%" IGRAPH_PRId " ", from, to);
378| 1.10k| }
379| 75.0k| ret2 = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 75.0k|#define VECTOR(v) ((v).stor_begin)
------------------
380| 75.0k| ret3 = fputc('\n', outstream);
381| 75.0k| if (ret1 < 0 || ret2 < 0 || ret3 == EOF) {
------------------
| Branch (381:17): [True: 0, False: 75.0k]
| Branch (381:29): [True: 0, False: 75.0k]
| Branch (381:41): [True: 0, False: 75.0k]
------------------
382| 0| IGRAPH_ERROR("Writing LGL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
383| 0| }
384| 75.0k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 75.0k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
385| 75.0k| }
386| 108| igraph_vector_destroy(&wvec);
387| 108| IGRAPH_FINALLY_CLEAN(1);
388| 108| } else {
389| | /* Both names and weights */
390| 73| igraph_strvector_t nvec;
391| 73| igraph_vector_t wvec;
392| 73| IGRAPH_VECTOR_INIT_FINALLY(&wvec, ecount);
------------------
| | 104| 73| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 73| do { \
| | | | 657| 73| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 73| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 73| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 73]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 73| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 73]
| | | | ------------------
| | ------------------
| | 105| 73| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 73| do { \
| | | | 604| 73| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 73| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 73| * incorrect destructor function with the pointer */ \
| | | | 607| 73| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 73]
| | | | ------------------
| | | | 608| 73| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 73| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 73]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 73]
| | ------------------
------------------
393| 73| IGRAPH_STRVECTOR_INIT_FINALLY(&nvec, vcount);
------------------
| | 62| 73| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 73| do { \
| | | | 657| 73| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 73| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 73| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 73]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 73| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 73]
| | | | ------------------
| | ------------------
| | 63| 73| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 73| do { \
| | | | 604| 73| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 73| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 73| * incorrect destructor function with the pointer */ \
| | | | 607| 73| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 73]
| | | | ------------------
| | | | 608| 73| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 73| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 73]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 73]
| | ------------------
------------------
394| 73| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 73| do { \
| | 657| 73| igraph_error_t igraph_i_ret = (expr); \
| | 658| 73| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 73| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 73]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 73| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 73]
| | ------------------
------------------
395| 73| igraph_ess_all(IGRAPH_EDGEORDER_ID),
396| 73| &wvec));
397| 73| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 73| do { \
| | 657| 73| igraph_error_t igraph_i_ret = (expr); \
| | 658| 73| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 73| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 73]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 73| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 73]
| | ------------------
------------------
398| 73| igraph_vss_all(),
399| 73| &nvec));
400| 19.7k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 19.7k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (400:16): [True: 19.7k, False: 59]
------------------
401| 19.7k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 19.7k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 19.7k]
| | ------------------
| | 406| 19.7k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 19.7k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
402| 19.7k| igraph_int_t from, to;
403| 19.7k| int ret = 0, ret2;
404| 19.7k| const char *str1, *str2;
405| |
406| 19.7k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 19.7k| do { \
| | 657| 19.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19.7k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.7k]
| | ------------------
------------------
407| 19.7k| str2 = igraph_strvector_get(&nvec, to);
408| 19.7k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 19.7k| do { \
| | 657| 19.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 13, False: 19.6k]
| | | | ------------------
| | ------------------
| | 659| 13| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 13| do { \
| | | | 427| 13| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 13| return igraph_errno ; \
| | | | 429| 13| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 13| } \
| | 661| 19.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.6k]
| | ------------------
------------------
409| |
410| 19.6k| if (from == actvertex) {
------------------
| Branch (410:17): [True: 19.3k, False: 327]
------------------
411| 19.3k| ret = fprintf(outstream, "%s ", str2);
412| 19.3k| } else {
413| 327| actvertex = from;
414| 327| str1 = igraph_strvector_get(&nvec, from);
415| 327| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 327| do { \
| | 657| 327| igraph_error_t igraph_i_ret = (expr); \
| | 658| 327| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 327| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 326]
| | | | ------------------
| | ------------------
| | 659| 1| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 1| do { \
| | | | 427| 1| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 1| return igraph_errno ; \
| | | | 429| 1| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 1| } \
| | 661| 327| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 326]
| | ------------------
------------------
416| 326| ret = fprintf(outstream, "# %s\n%s ", str1, str2);
417| 326| }
418| 19.6k| if (ret < 0) {
------------------
| Branch (418:17): [True: 0, False: 19.6k]
------------------
419| 0| IGRAPH_ERROR("Writing LGL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
420| 0| }
421| 19.6k| ret = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 19.6k|#define VECTOR(v) ((v).stor_begin)
------------------
422| 19.6k| ret2 = fputc('\n', outstream);
423| 19.6k| if (ret < 0 || ret2 == EOF) {
------------------
| Branch (423:17): [True: 0, False: 19.6k]
| Branch (423:28): [True: 0, False: 19.6k]
------------------
424| 0| IGRAPH_ERROR("Writing LGL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
425| 0| }
426| 19.6k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 19.6k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
427| 19.6k| }
428| 59| igraph_strvector_destroy(&nvec);
429| 59| igraph_vector_destroy(&wvec);
430| 59| IGRAPH_FINALLY_CLEAN(2);
431| 59| }
432| |
433| 3.19k| if (isolates) {
------------------
| Branch (433:9): [True: 0, False: 3.19k]
------------------
434| 0| igraph_int_t nov = vcount;
435| 0| igraph_int_t i;
436| 0| int ret = 0;
437| 0| igraph_int_t deg;
438| 0| igraph_strvector_t nvec;
439| 0| const char *str;
440| |
441| 0| IGRAPH_STRVECTOR_INIT_FINALLY(&nvec, 1);
------------------
| | 62| 0| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 0| do { \
| | | | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 0| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 63| 0| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 0| do { \
| | | | 604| 0| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 0| * incorrect destructor function with the pointer */ \
| | | | 607| 0| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 0]
| | | | ------------------
| | | | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 0| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 0]
| | ------------------
------------------
442| 0| for (i = 0; i < nov; i++) {
------------------
| Branch (442:21): [True: 0, False: 0]
------------------
443| 0| IGRAPH_CHECK(igraph_degree_1(graph, °, i, IGRAPH_ALL, IGRAPH_LOOPS));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
444| 0| if (deg == 0) {
------------------
| Branch (444:17): [True: 0, False: 0]
------------------
445| 0| if (names == NULL) {
------------------
| Branch (445:21): [True: 0, False: 0]
------------------
446| 0| ret = fprintf(outstream, "# %" IGRAPH_PRId "\n", i);
447| 0| } else {
448| 0| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
449| 0| igraph_vss_1(i), &nvec));
450| 0| str = igraph_strvector_get(&nvec, 0);
451| 0| IGRAPH_CHECK(check_name(str));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
452| 0| ret = fprintf(outstream, "# %s\n", str);
453| 0| }
454| 0| }
455| 0| if (ret < 0) {
------------------
| Branch (455:17): [True: 0, False: 0]
------------------
456| 0| IGRAPH_ERROR("Writing LGL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
457| 0| }
458| 0| }
459| 0| igraph_strvector_destroy(&nvec);
460| 0| IGRAPH_FINALLY_CLEAN(1);
461| 0| }
462| |
463| 3.19k| igraph_eit_destroy(&it);
464| 3.19k| IGRAPH_FINALLY_CLEAN(1);
465| 3.19k| return IGRAPH_SUCCESS;
466| 3.19k|}
lgl.c:check_name:
214| 35.8k|static igraph_error_t check_name(const char *name) {
215| 35.8k| size_t len = 0;
216| |
217| 45.2M| for (; *name != '\0'; name++, len++) {
------------------
| Branch (217:12): [True: 45.2M, False: 35.7k]
------------------
218| 45.2M| if ( *name <= 0x020 /* space or non-printable */
------------------
| Branch (218:16): [True: 50, False: 45.2M]
------------------
219| 45.2M| || *name == 0x7f /* del */
------------------
| Branch (219:16): [True: 5, False: 45.2M]
------------------
220| 45.2M| || *name == '#') {
------------------
| Branch (220:16): [True: 62, False: 45.2M]
------------------
221| 117| IGRAPH_ERRORF("The LGL format does not allow non-printable characters, spaces or '#' in vertex names. "
------------------
| | 464| 117| do { \
| | 465| 117| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 117| igraph_errno, __VA_ARGS__) ; \
| | 467| 117| return igraph_errno; \
| | 468| 117| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
222| 117| "Character code 0x%02X found.", IGRAPH_EINVAL,
223| 117| *name);
224| 117| }
225| 45.2M| }
226| 35.7k| if (len == 0) {
------------------
| Branch (226:9): [True: 31, False: 35.6k]
------------------
227| 31| IGRAPH_ERROR("The LGL format does not support empty vertex names.", IGRAPH_EINVAL);
------------------
| | 426| 31| do { \
| | 427| 31| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 31| return igraph_errno ; \
| | 429| 31| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
228| 31| }
229| 35.6k| return IGRAPH_SUCCESS;
230| 35.7k|}
igraph_read_graph_ncol:
110| 3.24k| igraph_bool_t directed) {
111| |
112| 3.24k| igraph_vector_int_t edges;
113| 3.24k| igraph_vector_t ws;
114| 3.24k| igraph_trie_t trie = IGRAPH_TRIE_NULL;
------------------
| | 52| 3.24k| { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 60| 3.24k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 44| 3.24k|#define IGRAPH_VECTOR_PTR_NULL { 0,0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 99| 3.24k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
| | ------------------
| | 53| 3.24k| 0, 0, IGRAPH_STRVECTOR_NULL }
| | ------------------
| | | | 60| 3.24k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
------------------
115| 3.24k| igraph_int_t no_of_nodes;
116| 3.24k| igraph_int_t no_predefined = 0;
117| 3.24k| igraph_attribute_record_list_t name, weight;
118| 3.24k| igraph_attribute_record_list_t *pname = NULL, *pweight = NULL;
119| 3.24k| igraph_attribute_record_t *namerec, *weightrec;
120| 3.24k| const char *namestr = "name", *weightstr = "weight";
121| 3.24k| igraph_i_ncol_parsedata_t context;
122| |
123| 3.24k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0);
------------------
| | 119| 3.24k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.24k| do { \
| | | | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.24k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.24k]
| | | | ------------------
| | ------------------
| | 120| 3.24k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.24k| do { \
| | | | 604| 3.24k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.24k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.24k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.24k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.24k]
| | | | ------------------
| | | | 608| 3.24k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.24k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.24k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.24k]
| | ------------------
------------------
124| |
125| 3.24k| IGRAPH_TRIE_INIT_FINALLY(&trie, names);
------------------
| | 55| 3.24k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.24k| do { \
| | | | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.24k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.24k]
| | | | ------------------
| | ------------------
| | 56| 3.24k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.24k| do { \
| | | | 604| 3.24k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.24k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.24k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.24k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.24k]
| | | | ------------------
| | | | 608| 3.24k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.24k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.24k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.24k]
| | ------------------
------------------
126| 3.24k| IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);
------------------
| | 104| 3.24k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.24k| do { \
| | | | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.24k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.24k]
| | | | ------------------
| | ------------------
| | 105| 3.24k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.24k| do { \
| | | | 604| 3.24k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.24k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.24k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.24k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.24k]
| | | | ------------------
| | | | 608| 3.24k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.24k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.24k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.24k]
| | ------------------
------------------
127| |
128| | /* Add the predefined names, if any */
129| 3.24k| if (predefnames != 0) {
------------------
| Branch (129:9): [True: 0, False: 3.24k]
------------------
130| 0| igraph_int_t i, id, n;
131| 0| const char *key;
132| 0| n = no_predefined = igraph_strvector_size(predefnames);
133| 0| for (i = 0; i < n; i++) {
------------------
| Branch (133:21): [True: 0, False: 0]
------------------
134| 0| key = igraph_strvector_get(predefnames, i);
135| 0| IGRAPH_CHECK(igraph_trie_get(&trie, key, &id));
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
136| 0| if (id != i) {
------------------
| Branch (136:17): [True: 0, False: 0]
------------------
137| 0| IGRAPH_WARNING("Reading NCOL file, duplicate entry in predefined names.");
------------------
| | 797| 0| do { \
| | 798| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 0| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 0]
| | ------------------
------------------
138| 0| no_predefined--;
139| 0| }
140| 0| }
141| 0| }
142| |
143| 3.24k| context.has_weights = false;
144| 3.24k| context.vector = &edges;
145| 3.24k| context.weights = &ws;
146| 3.24k| context.trie = ≜
147| 3.24k| context.errmsg[0] = '\0';
148| 3.24k| context.igraph_errno = IGRAPH_SUCCESS;
149| |
150| 3.24k| igraph_ncol_yylex_init_extra(&context, &context.scanner);
151| 3.24k| IGRAPH_FINALLY(igraph_ncol_yylex_destroy_wrapper, context.scanner);
------------------
| | 603| 3.24k| do { \
| | 604| 3.24k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.24k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.24k| * incorrect destructor function with the pointer */ \
| | 607| 3.24k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.24k]
| | ------------------
| | 608| 3.24k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.24k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.24k]
| | ------------------
------------------
152| |
153| 3.24k| igraph_ncol_yyset_in(instream, context.scanner);
154| |
155| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */
156| 3.24k| IGRAPH_FINALLY_ENTER();
157| 3.24k| int err = igraph_ncol_yyparse(&context);
158| 3.24k| IGRAPH_FINALLY_EXIT();
159| 3.24k| switch (err) {
160| 3.24k| case 0: /* success */
------------------
| Branch (160:5): [True: 3.24k, False: 0]
------------------
161| 3.24k| break;
162| 0| case 1: /* parse error */
------------------
| Branch (162:5): [True: 0, False: 3.24k]
------------------
163| 0| if (context.errmsg[0] != '\0') {
------------------
| Branch (163:13): [True: 0, False: 0]
------------------
164| 0| IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
165| 0| } else if (context.igraph_errno != IGRAPH_SUCCESS) {
------------------
| Branch (165:20): [True: 0, False: 0]
------------------
166| 0| IGRAPH_ERROR("", context.igraph_errno);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
167| 0| } else {
168| 0| IGRAPH_ERROR("Cannot read NCOL file.", IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
169| 0| }
170| 0| break;
171| 0| case 2: /* out of memory */
------------------
| Branch (171:5): [True: 0, False: 3.24k]
------------------
172| 0| IGRAPH_ERROR("Cannot read NCOL file.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
173| 0| break;
174| 0| default: /* must never reach here */
------------------
| Branch (174:5): [True: 0, False: 3.24k]
------------------
175| | /* Hint: This will usually be triggered if an IGRAPH_CHECK() is used in a Bison
176| | * action instead of an IGRAPH_YY_CHECK(), resulting in an igraph errno being
177| | * returned in place of a Bison error code.
178| | * TODO: What if future Bison versions introduce error codes other than 0, 1 and 2?
179| | */
180| 0| IGRAPH_FATALF("Parser returned unexpected error code (%d) when reading NCOL file.", err);
------------------
| | 875| 0| do { \
| | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 877| 0| __VA_ARGS__); \
| | 878| 0| } while (0)
| | ------------------
| | | Branch (878:14): [Folded, False: 0]
| | ------------------
------------------
181| 3.24k| }
182| |
183| 3.24k| if (predefnames != 0 &&
------------------
| Branch (183:9): [True: 0, False: 3.24k]
------------------
184| 0| igraph_trie_size(&trie) != no_predefined) {
------------------
| Branch (184:9): [True: 0, False: 0]
------------------
185| 0| IGRAPH_WARNING("Unknown vertex/vertices found in NCOL file, predefined names extended.");
------------------
| | 797| 0| do { \
| | 798| 0| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 0| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 0]
| | ------------------
------------------
186| 0| }
187| |
188| | /* Prepare attributes if needed */
189| 3.24k| if (names) {
------------------
| Branch (189:9): [True: 3.24k, False: 0]
------------------
190| 3.24k| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1));
------------------
| | 656| 3.24k| do { \
| | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.24k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.24k]
| | ------------------
------------------
191| 3.24k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name);
------------------
| | 603| 3.24k| do { \
| | 604| 3.24k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.24k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.24k| * incorrect destructor function with the pointer */ \
| | 607| 3.24k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.24k]
| | ------------------
| | 608| 3.24k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.24k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.24k]
| | ------------------
------------------
192| |
193| 3.24k| namerec = igraph_attribute_record_list_get_ptr(&name, 0);
194| 3.24k| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr));
------------------
| | 656| 3.24k| do { \
| | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.24k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.24k]
| | ------------------
------------------
195| 3.24k| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.24k| do { \
| | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.24k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.24k]
| | ------------------
------------------
196| 3.24k| IGRAPH_CHECK(igraph_strvector_update(
------------------
| | 656| 3.24k| do { \
| | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.24k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.24k]
| | ------------------
------------------
197| 3.24k| namerec->value.as_strvector, igraph_i_trie_borrow_keys(context.trie))
198| 3.24k| );
199| |
200| 3.24k| pname = &name;
201| 3.24k| }
202| |
203| 3.24k| if (weights == IGRAPH_ADD_WEIGHTS_YES ||
------------------
| Branch (203:9): [True: 0, False: 3.24k]
------------------
204| 3.24k| (weights == IGRAPH_ADD_WEIGHTS_IF_PRESENT && context.has_weights)) {
------------------
| Branch (204:10): [True: 3.24k, False: 0]
| Branch (204:54): [True: 169, False: 3.08k]
------------------
205| 169| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1));
------------------
| | 656| 169| do { \
| | 657| 169| igraph_error_t igraph_i_ret = (expr); \
| | 658| 169| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 169| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 169]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 169| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 169]
| | ------------------
------------------
206| 169| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight);
------------------
| | 603| 169| do { \
| | 604| 169| /* the following branch makes the compiler check the compatibility of \
| | 605| 169| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 169| * incorrect destructor function with the pointer */ \
| | 607| 169| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 169]
| | ------------------
| | 608| 169| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 169| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 169]
| | ------------------
------------------
207| |
208| 169| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0);
209| 169| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr));
------------------
| | 656| 169| do { \
| | 657| 169| igraph_error_t igraph_i_ret = (expr); \
| | 658| 169| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 169| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 169]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 169| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 169]
| | ------------------
------------------
210| 169| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC));
------------------
| | 656| 169| do { \
| | 657| 169| igraph_error_t igraph_i_ret = (expr); \
| | 658| 169| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 169| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 169]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 169| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 169]
| | ------------------
------------------
211| 169| igraph_vector_swap(weightrec->value.as_vector, context.weights);
212| |
213| 169| pweight = &weight;
214| 169| }
215| |
216| 3.24k| if (igraph_vector_int_empty(&edges)) {
------------------
| Branch (216:9): [True: 889, False: 2.36k]
------------------
217| 889| no_of_nodes = 0;
218| 2.36k| } else {
219| 2.36k| no_of_nodes = igraph_vector_int_max(&edges) + 1;
220| 2.36k| }
221| |
222| | /* Create graph */
223| 3.24k| IGRAPH_CHECK(igraph_empty(graph, 0, directed));
------------------
| | 656| 3.24k| do { \
| | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.24k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.24k]
| | ------------------
------------------
224| 3.24k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.24k| do { \
| | 604| 3.24k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.24k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.24k| * incorrect destructor function with the pointer */ \
| | 607| 3.24k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.24k]
| | ------------------
| | 608| 3.24k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.24k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.24k]
| | ------------------
------------------
225| 3.24k| IGRAPH_CHECK(igraph_add_vertices(graph, no_of_nodes, pname));
------------------
| | 656| 3.24k| do { \
| | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.24k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.24k]
| | ------------------
------------------
226| 3.24k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));
------------------
| | 656| 3.24k| do { \
| | 657| 3.24k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.24k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.24k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.24k]
| | ------------------
------------------
227| |
228| 3.24k| if (pname) {
------------------
| Branch (228:9): [True: 3.24k, False: 0]
------------------
229| 3.24k| igraph_attribute_record_list_destroy(pname);
230| 3.24k| IGRAPH_FINALLY_CLEAN(1);
231| 3.24k| }
232| 3.24k| if (pweight) {
------------------
| Branch (232:9): [True: 169, False: 3.08k]
------------------
233| 169| igraph_attribute_record_list_destroy(pweight);
234| 169| IGRAPH_FINALLY_CLEAN(1);
235| 169| }
236| 3.24k| igraph_vector_destroy(&ws);
237| 3.24k| igraph_trie_destroy(&trie);
238| 3.24k| igraph_vector_int_destroy(&edges);
239| 3.24k| igraph_ncol_yylex_destroy(context.scanner);
240| 3.24k| IGRAPH_FINALLY_CLEAN(5); /* +1 for 'graph' */
241| |
242| 3.24k| return IGRAPH_SUCCESS;
243| 3.24k|}
igraph_write_graph_ncol:
301| 3.34k| const char *names, const char *weights) {
302| 3.34k| igraph_eit_t it;
303| 3.34k| igraph_attribute_type_t nametype, weighttype;
304| |
305| 3.34k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID),
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
306| 3.34k| &it));
307| 3.34k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
308| |
309| | /* Check if we have the names attribute */
310| 3.34k| if (names && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
------------------
| Branch (310:9): [True: 3.34k, False: 0]
| Branch (310:18): [True: 2.87k, False: 465]
------------------
311| 3.34k| names)) {
312| 2.87k| IGRAPH_WARNINGF("Names attribute '%s' does not exist.", names);
------------------
| | 777| 2.87k| do { \
| | 778| 2.87k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.87k| __VA_ARGS__); \
| | 780| 2.87k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.87k]
| | ------------------
------------------
313| 2.87k| names = NULL;
314| 2.87k| }
315| 3.34k| if (names) {
------------------
| Branch (315:9): [True: 465, False: 2.87k]
------------------
316| 465| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &nametype,
------------------
| | 656| 465| do { \
| | 657| 465| igraph_error_t igraph_i_ret = (expr); \
| | 658| 465| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 465| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 465]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 465| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 465]
| | ------------------
------------------
317| 465| IGRAPH_ATTRIBUTE_VERTEX, names));
318| 465| if (nametype != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (318:13): [True: 48, False: 417]
------------------
319| 48| IGRAPH_WARNINGF("Ignoring names attribute '%s', "
------------------
| | 777| 48| do { \
| | 778| 48| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 48| __VA_ARGS__); \
| | 780| 48| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 48]
| | ------------------
------------------
320| 48| "attribute type is not a string.", names);
321| 48| names = NULL;
322| 48| }
323| 465| }
324| |
325| | /* Check the weights as well */
326| 3.34k| if (weights && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, weights)) {
------------------
| Branch (326:9): [True: 3.34k, False: 0]
| Branch (326:20): [True: 3.10k, False: 232]
------------------
327| 3.10k| IGRAPH_WARNINGF("Weights attribute '%s' does not exist.", weights);
------------------
| | 777| 3.10k| do { \
| | 778| 3.10k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.10k| __VA_ARGS__); \
| | 780| 3.10k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.10k]
| | ------------------
------------------
328| 3.10k| weights = NULL;
329| 3.10k| }
330| 3.34k| if (weights) {
------------------
| Branch (330:9): [True: 232, False: 3.10k]
------------------
331| 232| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &weighttype,
------------------
| | 656| 232| do { \
| | 657| 232| igraph_error_t igraph_i_ret = (expr); \
| | 658| 232| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 232| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 232]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 232| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 232]
| | ------------------
------------------
332| 232| IGRAPH_ATTRIBUTE_EDGE, weights));
333| 232| if (weighttype != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (333:13): [True: 51, False: 181]
------------------
334| 51| IGRAPH_WARNINGF("Ignoring weights attribute '%s', "
------------------
| | 777| 51| do { \
| | 778| 51| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 51| __VA_ARGS__); \
| | 780| 51| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 51]
| | ------------------
------------------
335| 51| "attribute type is not numeric.", weights);
336| 51| weights = NULL;
337| 51| }
338| 232| }
339| |
340| 3.34k| if (names == NULL && weights == NULL) {
------------------
| Branch (340:9): [True: 2.92k, False: 417]
| Branch (340:26): [True: 2.81k, False: 108]
------------------
341| | /* No names, no weights */
342| 236k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 236k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (342:16): [True: 233k, False: 2.81k]
------------------
343| 233k| igraph_int_t from, to;
344| 233k| int ret;
345| |
346| 233k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 233k| do { \
| | 657| 466k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 233k, False: 0]
| | ------------------
| | 658| 233k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 233k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 233k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 233k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 233k]
| | ------------------
------------------
347| 233k| ret = fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId "\n", from, to);
348| 233k| if (ret < 0) {
------------------
| Branch (348:17): [True: 0, False: 233k]
------------------
349| 0| IGRAPH_ERROR("Writing NCOL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
350| 0| }
351| 233k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 233k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
352| 233k| }
353| 2.81k| } else if (weights == NULL) {
------------------
| Branch (353:16): [True: 344, False: 181]
------------------
354| | /* No weights, but use names */
355| 344| igraph_strvector_t nvec;
356| 344| IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
------------------
| | 656| 344| do { \
| | 657| 344| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344]
| | ------------------
------------------
357| 344| IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
------------------
| | 603| 344| do { \
| | 604| 344| /* the following branch makes the compiler check the compatibility of \
| | 605| 344| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 344| * incorrect destructor function with the pointer */ \
| | 607| 344| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 344]
| | ------------------
| | 608| 344| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 344| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 344]
| | ------------------
------------------
358| 344| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 344| do { \
| | 657| 344| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344]
| | ------------------
------------------
359| 344| igraph_vss_all(),
360| 344| &nvec));
361| 15.8k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 15.8k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (361:16): [True: 15.6k, False: 260]
------------------
362| 15.6k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 15.6k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 15.6k, False: 0]
| | ------------------
| | 406| 15.6k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
363| 15.6k| igraph_int_t from, to;
364| 15.6k| int ret = 0;
365| 15.6k| const char *str1, *str2;
366| |
367| 15.6k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 15.6k| do { \
| | 657| 15.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 15.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.6k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 15.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.6k]
| | ------------------
------------------
368| 15.6k| str1 = igraph_strvector_get(&nvec, from);
369| 15.6k| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 15.6k| do { \
| | 657| 15.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 15.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 82, False: 15.5k]
| | | | ------------------
| | ------------------
| | 659| 82| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 82| do { \
| | | | 427| 82| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 82| return igraph_errno ; \
| | | | 429| 82| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 82| } \
| | 661| 15.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.5k]
| | ------------------
------------------
370| 15.5k| str2 = igraph_strvector_get(&nvec, to);
371| 15.5k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 15.5k| do { \
| | 657| 15.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 15.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 15.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 2, False: 15.5k]
| | | | ------------------
| | ------------------
| | 659| 2| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 2| do { \
| | | | 427| 2| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 2| return igraph_errno ; \
| | | | 429| 2| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 2| } \
| | 661| 15.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.5k]
| | ------------------
------------------
372| 15.5k| ret = fprintf(outstream, "%s %s\n", str1, str2);
373| 15.5k| if (ret < 0) {
------------------
| Branch (373:17): [True: 0, False: 15.5k]
------------------
374| 0| IGRAPH_ERROR("Writing NCOL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
375| 0| }
376| 15.5k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 15.5k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
377| 15.5k| }
378| 260| igraph_strvector_destroy(&nvec);
379| 260| IGRAPH_FINALLY_CLEAN(1);
380| 260| } else if (names == NULL) {
------------------
| Branch (380:16): [True: 108, False: 73]
------------------
381| | /* No names but weights */
382| 108| igraph_vector_t wvec;
383| 108| IGRAPH_VECTOR_INIT_FINALLY(&wvec, igraph_ecount(graph));
------------------
| | 104| 108| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 108| do { \
| | | | 657| 108| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 108| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 108| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 108]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 108| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 108]
| | | | ------------------
| | ------------------
| | 105| 108| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 108| do { \
| | | | 604| 108| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 108| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 108| * incorrect destructor function with the pointer */ \
| | | | 607| 108| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 108]
| | | | ------------------
| | | | 608| 108| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 108| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 108]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 108]
| | ------------------
------------------
384| 108| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 108| do { \
| | 657| 108| igraph_error_t igraph_i_ret = (expr); \
| | 658| 108| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 108| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 108]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 108| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 108]
| | ------------------
------------------
385| 108| igraph_ess_all(IGRAPH_EDGEORDER_ID),
386| 108| &wvec));
387| 75.1k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 75.1k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (387:16): [True: 75.0k, False: 108]
------------------
388| 75.0k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 75.0k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 75.0k, False: 0]
| | ------------------
| | 406| 75.0k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
389| 75.0k| igraph_int_t from, to;
390| 75.0k| int ret1, ret2, ret3;
391| |
392| 75.0k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 75.0k| do { \
| | 657| 75.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 75.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 75.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 75.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 75.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 75.0k]
| | ------------------
------------------
393| 75.0k| ret1 = fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " ", from, to);
394| 75.0k| ret2 = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 75.0k|#define VECTOR(v) ((v).stor_begin)
------------------
395| 75.0k| ret3 = fputc('\n', outstream);
396| 75.0k| if (ret1 < 0 || ret2 < 0 || ret3 == EOF) {
------------------
| Branch (396:17): [True: 0, False: 75.0k]
| Branch (396:29): [True: 0, False: 75.0k]
| Branch (396:41): [True: 0, False: 75.0k]
------------------
397| 0| IGRAPH_ERROR("Writing NCOL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
398| 0| }
399| 75.0k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 75.0k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
400| 75.0k| }
401| 108| igraph_vector_destroy(&wvec);
402| 108| IGRAPH_FINALLY_CLEAN(1);
403| 108| } else {
404| | /* Both names and weights */
405| 73| igraph_strvector_t nvec;
406| 73| igraph_vector_t wvec;
407| 73| IGRAPH_VECTOR_INIT_FINALLY(&wvec, igraph_ecount(graph));
------------------
| | 104| 73| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 73| do { \
| | | | 657| 73| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 73| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 73| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 73]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 73| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 73]
| | | | ------------------
| | ------------------
| | 105| 73| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 73| do { \
| | | | 604| 73| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 73| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 73| * incorrect destructor function with the pointer */ \
| | | | 607| 73| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 73]
| | | | ------------------
| | | | 608| 73| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 73| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 73]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 73]
| | ------------------
------------------
408| 73| IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
------------------
| | 656| 73| do { \
| | 657| 73| igraph_error_t igraph_i_ret = (expr); \
| | 658| 73| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 73| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 73]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 73| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 73]
| | ------------------
------------------
409| 73| IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
------------------
| | 603| 73| do { \
| | 604| 73| /* the following branch makes the compiler check the compatibility of \
| | 605| 73| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 73| * incorrect destructor function with the pointer */ \
| | 607| 73| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 73]
| | ------------------
| | 608| 73| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 73| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 73]
| | ------------------
------------------
410| 73| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 73| do { \
| | 657| 73| igraph_error_t igraph_i_ret = (expr); \
| | 658| 73| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 73| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 73]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 73| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 73]
| | ------------------
------------------
411| 73| igraph_ess_all(IGRAPH_EDGEORDER_ID),
412| 73| &wvec));
413| 73| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 73| do { \
| | 657| 73| igraph_error_t igraph_i_ret = (expr); \
| | 658| 73| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 73| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 73]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 73| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 73]
| | ------------------
------------------
414| 73| igraph_vss_all(),
415| 73| &nvec));
416| 19.7k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 19.7k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (416:16): [True: 19.7k, False: 66]
------------------
417| 19.7k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 19.7k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 19.7k, False: 0]
| | ------------------
| | 406| 19.7k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
418| 19.7k| igraph_int_t from, to;
419| 19.7k| int ret = 0, ret2 = 0;
420| 19.7k| const char *str1, *str2;
421| |
422| 19.7k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 19.7k| do { \
| | 657| 19.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19.7k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.7k]
| | ------------------
------------------
423| 19.7k| str1 = igraph_strvector_get(&nvec, from);
424| 19.7k| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 19.7k| do { \
| | 657| 19.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 6, False: 19.6k]
| | | | ------------------
| | ------------------
| | 659| 6| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 6| do { \
| | | | 427| 6| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 6| return igraph_errno ; \
| | | | 429| 6| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 6| } \
| | 661| 19.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.6k]
| | ------------------
------------------
425| 19.6k| str2 = igraph_strvector_get(&nvec, to);
426| 19.6k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 19.6k| do { \
| | 657| 19.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 19.6k]
| | | | ------------------
| | ------------------
| | 659| 1| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 1| do { \
| | | | 427| 1| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 1| return igraph_errno ; \
| | | | 429| 1| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 1| } \
| | 661| 19.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.6k]
| | ------------------
------------------
427| 19.6k| ret = fprintf(outstream, "%s %s ", str1, str2);
428| 19.6k| if (ret < 0) {
------------------
| Branch (428:17): [True: 0, False: 19.6k]
------------------
429| 0| IGRAPH_ERROR("Writing NCOL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
430| 0| }
431| 19.6k| ret = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 19.6k|#define VECTOR(v) ((v).stor_begin)
------------------
432| 19.6k| ret2 = fputc('\n', outstream);
433| 19.6k| if (ret < 0 || ret2 == EOF) {
------------------
| Branch (433:17): [True: 0, False: 19.6k]
| Branch (433:28): [True: 0, False: 19.6k]
------------------
434| 0| IGRAPH_ERROR("Writing NCOL file failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
435| 0| }
436| 19.6k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 19.6k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
437| 19.6k| }
438| 66| igraph_strvector_destroy(&nvec);
439| 66| igraph_vector_destroy(&wvec);
440| 66| IGRAPH_FINALLY_CLEAN(2);
441| 66| }
442| |
443| 3.24k| igraph_eit_destroy(&it);
444| 3.24k| IGRAPH_FINALLY_CLEAN(1);
445| 3.24k| return IGRAPH_SUCCESS;
446| 3.34k|}
ncol.c:check_name:
246| 70.5k|static igraph_error_t check_name(const char *name) {
247| 70.5k| size_t len = 0;
248| |
249| 71.6M| for (; *name != '\0'; name++, len++) {
------------------
| Branch (249:12): [True: 71.5M, False: 70.4k]
------------------
250| 71.5M| if ( *name <= 0x020 /* space or non-printable */
------------------
| Branch (250:16): [True: 55, False: 71.5M]
------------------
251| 71.5M| || *name == 0x7f /* del */) {
------------------
| Branch (251:16): [True: 5, False: 71.5M]
------------------
252| 60| IGRAPH_ERRORF("The NCOL format does not allow non-printable characters or spaces in vertex names. "
------------------
| | 464| 60| do { \
| | 465| 60| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 60| igraph_errno, __VA_ARGS__) ; \
| | 467| 60| return igraph_errno; \
| | 468| 60| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
253| 60| "Character code 0x%02X found.", IGRAPH_EINVAL,
254| 60| *name);
255| 60| }
256| 71.5M| }
257| 70.4k| if (len == 0) {
------------------
| Branch (257:9): [True: 31, False: 70.4k]
------------------
258| 31| IGRAPH_ERROR("The NCOL format does not support empty vertex names.", IGRAPH_EINVAL);
------------------
| | 426| 31| do { \
| | 427| 31| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 31| return igraph_errno ; \
| | 429| 31| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
259| 31| }
260| 70.4k| return IGRAPH_SUCCESS;
261| 70.4k|}
igraph_write_graph_pajek:
397| 3.34k|igraph_error_t igraph_write_graph_pajek(const igraph_t *graph, FILE *outstream) {
398| 3.34k| igraph_int_t no_of_nodes = igraph_vcount(graph);
399| |
400| 3.34k| igraph_attribute_type_t vtypes[V_LAST], etypes[E_LAST];
401| 3.34k| igraph_bool_t write_vertex_attrs = false;
402| |
403| | /* Same order as the #define's */
404| 3.34k| const char *vnames[] = { "name", "x", "y", "z", "shape", "xfact", "yfact",
405| 3.34k| "labeldist", "labeldegree2", "framewidth",
406| 3.34k| "fontsize", "rotation", "radius",
407| 3.34k| "diamondratio", "labeldegree",
408| 3.34k| "font", "url", "color", "framecolor",
409| 3.34k| "labelcolor"
410| 3.34k| };
411| 3.34k| IGRAPH_STATIC_ASSERT(sizeof(vnames) / sizeof(vnames[0]) == V_LAST);
------------------
| | 68| 3.34k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
412| |
413| | /* Arrays called xxx[] are igraph attribute names,
414| | * xxx2[] are the corresponding Pajek names. */
415| 3.34k| const char *vnumnames[] = { "xfact", "yfact", "labeldist",
416| 3.34k| "labeldegree2", "framewidth", "fontsize",
417| 3.34k| "rotation", "radius", "diamondratio",
418| 3.34k| "labeldegree"
419| 3.34k| };
420| 3.34k| const char *vnumnames2[] = { "x_fact", "y_fact", "lr", "lphi", "bw",
421| 3.34k| "fos", "phi", "r", "q", "la"
422| 3.34k| };
423| 3.34k| IGRAPH_STATIC_ASSERT(sizeof(vnumnames) == sizeof(vnumnames2));
------------------
| | 68| 3.34k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
424| |
425| 3.34k| const char *vstrnames[] = { "font", "url", "color", "framecolor",
426| 3.34k| "labelcolor"
427| 3.34k| };
428| 3.34k| const char *vstrnames2[] = { "font", "url", "ic", "bc", "lc" };
429| 3.34k| IGRAPH_STATIC_ASSERT(sizeof(vstrnames) == sizeof(vstrnames2));
------------------
| | 68| 3.34k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
430| |
431| | /* Same order as the #define's */
432| 3.34k| const char *enames[] = { "weight" };
433| 3.34k| IGRAPH_STATIC_ASSERT(sizeof(enames) / sizeof(enames[0]) == E_LAST);
------------------
| | 68| 3.34k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
434| |
435| 3.34k| const char *enumnames[] = { "arrowsize", "edgewidth", "hook1", "hook2",
436| 3.34k| "angle1", "angle2", "velocity1", "velocity2",
437| 3.34k| "arrowpos", "labelpos", "labelangle",
438| 3.34k| "labelangle2", "labeldegree", "fontsize"
439| 3.34k| };
440| 3.34k| const char *enumnames2[] = { "s", "w", "h1", "h2", "a1", "a2", "k1", "k2",
441| 3.34k| "ap", "lp", "lr", "lphi", "la", "fos"
442| 3.34k| };
443| 3.34k| IGRAPH_STATIC_ASSERT(sizeof(enumnames) == sizeof(enumnames2));
------------------
| | 68| 3.34k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
444| |
445| 3.34k| const char *estrnames[] = { "arrowtype", "linepattern", "label",
446| 3.34k| "labelcolor", "color", "font"
447| 3.34k| };
448| 3.34k| const char *estrnames2[] = { "a", "p", "l", "lc", "c", "font" };
449| 3.34k| IGRAPH_STATIC_ASSERT(sizeof(estrnames) == sizeof(estrnames2));
------------------
| | 68| 3.34k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
450| |
451| | /* Newer Pajek versions support both Unix and Windows-style line endings,
452| | * so we just use Unix style. This will get converted to CRLF on Windows
453| | * when the file is opened in text mode */
454| 3.34k| const char *newline = "\n";
455| |
456| 3.34k| igraph_es_t es;
457| 3.34k| igraph_eit_t eit;
458| |
459| 3.34k| igraph_vector_t numv;
460| 3.34k| igraph_strvector_t strv;
461| |
462| 3.34k| igraph_vector_int_t ex_numa;
463| 3.34k| igraph_vector_int_t ex_stra;
464| 3.34k| igraph_vector_int_t vx_numa;
465| 3.34k| igraph_vector_int_t vx_stra;
466| |
467| 3.34k| const char *s;
468| 3.34k| char *escaped;
469| |
470| 3.34k| igraph_bool_t bipartite = false;
471| 3.34k| igraph_vector_int_t bip_index, bip_index2;
472| 3.34k| igraph_vector_bool_t bvec;
473| 3.34k| igraph_int_t notop = 0, nobottom = 0;
474| |
475| 3.34k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.34k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 105| 3.34k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.34k]
| | ------------------
------------------
476| 3.34k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.34k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 63| 3.34k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.34k]
| | ------------------
------------------
477| |
478| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ex_numa, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
479| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ex_stra, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
480| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vx_numa, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
481| 3.34k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vx_stra, 0);
------------------
| | 119| 3.34k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.34k| do { \
| | | | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | 120| 3.34k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.34k| do { \
| | | | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.34k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.34k]
| | | | ------------------
| | | | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.34k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.34k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.34k]
| | ------------------
------------------
482| |
483| | /* Check if graph is bipartite, i.e. whether it has a Boolean 'type' vertex attribute. */
484| 3.34k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, "type")) {
------------------
| Branch (484:9): [True: 33, False: 3.30k]
------------------
485| 33| igraph_attribute_type_t type_type;
486| 33| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &type_type, IGRAPH_ATTRIBUTE_VERTEX, "type"));
------------------
| | 656| 33| do { \
| | 657| 33| igraph_error_t igraph_i_ret = (expr); \
| | 658| 33| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 33| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 33]
| | ------------------
------------------
487| 33| if (type_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (487:13): [True: 32, False: 1]
------------------
488| 32| bipartite = true; write_vertex_attrs = true;
489| | /* Count top and bottom vertices, we go over them twice,
490| | because we want to keep their original order */
491| 32| IGRAPH_VECTOR_INT_INIT_FINALLY(&bip_index, no_of_nodes);
------------------
| | 119| 32| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 32| do { \
| | | | 657| 32| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 32| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 32| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 32]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 32| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 32]
| | | | ------------------
| | ------------------
| | 120| 32| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 32| do { \
| | | | 604| 32| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 32| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 32| * incorrect destructor function with the pointer */ \
| | | | 607| 32| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 32]
| | | | ------------------
| | | | 608| 32| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 32| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 32]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 32]
| | ------------------
------------------
492| 32| IGRAPH_VECTOR_INT_INIT_FINALLY(&bip_index2, no_of_nodes);
------------------
| | 119| 32| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 32| do { \
| | | | 657| 32| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 32| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 32| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 32]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 32| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 32]
| | | | ------------------
| | ------------------
| | 120| 32| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 32| do { \
| | | | 604| 32| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 32| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 32| * incorrect destructor function with the pointer */ \
| | | | 607| 32| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 32]
| | | | ------------------
| | | | 608| 32| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 32| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 32]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 32]
| | ------------------
------------------
493| 32| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&bvec, 1);
------------------
| | 109| 32| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 32| do { \
| | | | 657| 32| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 32| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 32| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 32]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 32| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 32]
| | | | ------------------
| | ------------------
| | 110| 32| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 32| do { \
| | | | 604| 32| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 32| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 32| * incorrect destructor function with the pointer */ \
| | | | 607| 32| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 32]
| | | | ------------------
| | | | 608| 32| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 32| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 32]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 32]
| | ------------------
------------------
494| 453| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (494:38): [True: 421, False: 32]
------------------
495| 421| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph,
------------------
| | 656| 421| do { \
| | 657| 421| igraph_error_t igraph_i_ret = (expr); \
| | 658| 421| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 421| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 421]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 421| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 421]
| | ------------------
------------------
496| 421| "type", igraph_vss_1(i), &bvec));
497| 421| if (VECTOR(bvec)[0]) {
------------------
| | 60| 421|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (497:21): [True: 0, False: 421]
------------------
498| 0| notop++;
499| 421| } else {
500| 421| nobottom++;
501| 421| }
502| 421| }
503| 453| for (igraph_int_t i = 0, bptr = 0, tptr = nobottom; i < no_of_nodes; i++) {
------------------
| Branch (503:65): [True: 421, False: 32]
------------------
504| 421| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph,
------------------
| | 656| 421| do { \
| | 657| 421| igraph_error_t igraph_i_ret = (expr); \
| | 658| 421| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 421| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 421]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 421| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 421]
| | ------------------
------------------
505| 421| "type", igraph_vss_1(i), &bvec));
506| 421| if (VECTOR(bvec)[0]) {
------------------
| | 60| 421|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (506:21): [True: 0, False: 421]
------------------
507| 0| VECTOR(bip_index)[tptr] = i;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
508| 0| VECTOR(bip_index2)[i] = tptr;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
509| 0| tptr++;
510| 421| } else {
511| 421| VECTOR(bip_index)[bptr] = i;
------------------
| | 60| 421|#define VECTOR(v) ((v).stor_begin)
------------------
512| 421| VECTOR(bip_index2)[i] = bptr;
------------------
| | 60| 421|#define VECTOR(v) ((v).stor_begin)
------------------
513| 421| bptr++;
514| 421| }
515| 421| }
516| 32| igraph_vector_bool_destroy(&bvec);
517| 32| IGRAPH_FINALLY_CLEAN(1);
518| 32| }
519| 33| }
520| |
521| | /* Write header */
522| 3.34k| if (bipartite) {
------------------
| Branch (522:9): [True: 32, False: 3.30k]
------------------
523| 32| if (fprintf(outstream, "*Vertices %" IGRAPH_PRId " %" IGRAPH_PRId "%s", no_of_nodes, nobottom,
------------------
| Branch (523:13): [True: 0, False: 32]
------------------
524| 32| newline) < 0) {
525| 0| IGRAPH_ERROR("Cannot write pajek file.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
526| 0| }
527| 3.30k| } else {
528| 3.30k| if (fprintf(outstream, "*Vertices %" IGRAPH_PRId "%s", no_of_nodes, newline) < 0) {
------------------
| Branch (528:13): [True: 0, False: 3.30k]
------------------
529| 0| IGRAPH_ERROR("Cannot write pajek file.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
530| 0| }
531| 3.30k| }
532| |
533| | /* Check the vertex attributes, and determine if we need to write them. */
534| 3.34k| memset(vtypes, 0, sizeof(vtypes[0])*V_LAST);
------------------
| | 263| 3.34k|#define V_LAST 20
------------------
535| 70.1k| for (igraph_int_t i = 0; i < V_LAST; i++) {
------------------
| | 263| 70.1k|#define V_LAST 20
------------------
| Branch (535:30): [True: 66.8k, False: 3.34k]
------------------
536| 66.8k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vnames[i])) {
------------------
| Branch (536:13): [True: 141, False: 66.6k]
------------------
537| 141| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 141| do { \
| | 657| 141| igraph_error_t igraph_i_ret = (expr); \
| | 658| 141| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 141| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 141]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 141| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 141]
| | ------------------
------------------
538| 141| graph, &vtypes[i], IGRAPH_ATTRIBUTE_VERTEX, vnames[i]));
539| 141| write_vertex_attrs = true;
540| 66.6k| } else {
541| 66.6k| vtypes[i] = (igraph_attribute_type_t) -1;
542| 66.6k| }
543| 66.8k| }
544| 36.7k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(vnumnames) / sizeof(vnumnames[0])); i++) {
------------------
| Branch (544:30): [True: 33.4k, False: 3.34k]
------------------
545| 33.4k| igraph_attribute_type_t type;
546| 33.4k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vnumnames[i])) {
------------------
| Branch (546:13): [True: 25, False: 33.3k]
------------------
547| 25| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 25| do { \
| | 657| 25| igraph_error_t igraph_i_ret = (expr); \
| | 658| 25| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 25| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 25]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 25| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 25]
| | ------------------
------------------
548| 25| graph, &type, IGRAPH_ATTRIBUTE_VERTEX, vnumnames[i]));
549| 25| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (549:17): [True: 10, False: 15]
------------------
550| 10| IGRAPH_CHECK(igraph_vector_int_push_back(&vx_numa, i));
------------------
| | 656| 10| do { \
| | 657| 10| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 10| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10]
| | ------------------
------------------
551| 10| }
552| 25| }
553| 33.4k| }
554| 20.0k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(vstrnames) / sizeof(vstrnames[0])); i++) {
------------------
| Branch (554:30): [True: 16.7k, False: 3.34k]
------------------
555| 16.7k| igraph_attribute_type_t type;
556| 16.7k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vstrnames[i])) {
------------------
| Branch (556:13): [True: 41, False: 16.6k]
------------------
557| 41| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 41| do { \
| | 657| 41| igraph_error_t igraph_i_ret = (expr); \
| | 658| 41| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 41| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 41]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 41| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 41]
| | ------------------
------------------
558| 41| graph, &type, IGRAPH_ATTRIBUTE_VERTEX, vstrnames[i]));
559| 41| if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (559:17): [True: 35, False: 6]
------------------
560| 35| IGRAPH_CHECK(igraph_vector_int_push_back(&vx_stra, i));
------------------
| | 656| 35| do { \
| | 657| 35| igraph_error_t igraph_i_ret = (expr); \
| | 658| 35| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 35| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 35]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 35| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 35]
| | ------------------
------------------
561| 35| }
562| 41| }
563| 16.7k| }
564| |
565| | /* Write vertices */
566| 3.34k| if (write_vertex_attrs) {
------------------
| Branch (566:9): [True: 167, False: 3.17k]
------------------
567| 1.89k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (567:34): [True: 1.72k, False: 167]
------------------
568| 1.72k| igraph_int_t id = bipartite ? VECTOR(bip_index)[i] : i;
------------------
| | 60| 421|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (568:31): [True: 421, False: 1.30k]
------------------
569| |
570| | /* vertex ID */
571| 1.72k| fprintf(outstream, "%" IGRAPH_PRId, i + 1);
------------------
| | 63| 1.72k|# define IGRAPH_PRId PRId64
------------------
572| 1.72k| if (vtypes[V_ID] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 243| 1.72k|#define V_ID 0
------------------
| Branch (572:17): [True: 66, False: 1.65k]
------------------
573| 66| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 656| 66| do { \
| | 657| 66| igraph_error_t igraph_i_ret = (expr); \
| | 658| 66| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 66| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 66| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 66]
| | ------------------
------------------
574| 66| graph, vnames[V_ID], igraph_vss_1(id), &numv));
575| 66| fputs(" \"", outstream);
576| 66| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 66|#define VECTOR(v) ((v).stor_begin)
------------------
577| 66| fputc('"', outstream);
578| 1.65k| } else if (vtypes[V_ID] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 243| 1.65k|#define V_ID 0
------------------
| Branch (578:24): [True: 154, False: 1.50k]
------------------
579| 154| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 154| do { \
| | 657| 154| igraph_error_t igraph_i_ret = (expr); \
| | 658| 154| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 154| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 154]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 154| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 154]
| | ------------------
------------------
580| 154| graph, vnames[V_ID], igraph_vss_1(id), &strv));
581| 154| s = igraph_strvector_get(&strv, 0);
582| 154| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 154| do { \
| | 657| 154| igraph_error_t igraph_i_ret = (expr); \
| | 658| 154| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 154| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 154]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 154| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 154]
| | ------------------
------------------
583| 154| fprintf(outstream, " %s", escaped);
584| 154| IGRAPH_FREE(escaped);
------------------
| | 36| 154|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
585| 1.50k| } else {
586| 1.50k| fprintf(outstream, " \"%" IGRAPH_PRId "\"", id + 1);
587| 1.50k| }
588| |
589| | /* coordinates */
590| 1.72k| if (vtypes[V_X] == IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| | 244| 1.72k|#define V_X 1
------------------
| Branch (590:17): [True: 66, False: 1.65k]
------------------
591| 66| vtypes[V_Y] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 245| 66|#define V_Y 2
------------------
| Branch (591:17): [True: 0, False: 66]
------------------
592| 0| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
593| 0| graph, vnames[V_X], igraph_vss_1(id), &numv));
594| 0| fputc(' ', outstream);
595| 0| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
596| 0| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
597| 0| graph, vnames[V_Y], igraph_vss_1(id), &numv));
598| 0| fputc(' ', outstream);
599| 0| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
600| 0| if (vtypes[V_Z] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 246| 0|#define V_Z 3
------------------
| Branch (600:21): [True: 0, False: 0]
------------------
601| 0| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, vnames[V_Z],
------------------
| | 656| 0| do { \
| | 657| 0| igraph_error_t igraph_i_ret = (expr); \
| | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 0]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 0| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 0]
| | ------------------
------------------
602| 0| igraph_vss_1(id), &numv));
603| 0| fputc(' ', outstream);
604| 0| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
605| 0| }
606| 0| }
607| |
608| | /* shape */
609| 1.72k| if (vtypes[V_SHAPE] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 247| 1.72k|#define V_SHAPE 4
------------------
| Branch (609:17): [True: 194, False: 1.53k]
------------------
610| 194| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 194| do { \
| | 657| 194| igraph_error_t igraph_i_ret = (expr); \
| | 658| 194| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 194| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 194]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 194| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 194]
| | ------------------
------------------
611| 194| graph, vnames[V_SHAPE], igraph_vss_1(id), &strv));
612| 194| s = igraph_strvector_get(&strv, 0);
613| 194| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 194| do { \
| | 657| 194| igraph_error_t igraph_i_ret = (expr); \
| | 658| 194| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 194| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 194]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 194| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 194]
| | ------------------
------------------
614| 194| fprintf(outstream, " %s", escaped);
615| 194| IGRAPH_FREE(escaped);
------------------
| | 36| 194|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
616| 194| }
617| |
618| | /* numeric parameters */
619| 2.04k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vx_numa); j++) {
------------------
| Branch (619:38): [True: 322, False: 1.72k]
------------------
620| 322| igraph_int_t idx = VECTOR(vx_numa)[j];
------------------
| | 60| 322|#define VECTOR(v) ((v).stor_begin)
------------------
621| 322| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 656| 322| do { \
| | 657| 322| igraph_error_t igraph_i_ret = (expr); \
| | 658| 322| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 322| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 322]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 322| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 322]
| | ------------------
------------------
622| 322| graph, vnumnames[idx], igraph_vss_1(id), &numv));
623| 322| fprintf(outstream, " %s ", vnumnames2[idx]);
624| 322| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 322|#define VECTOR(v) ((v).stor_begin)
------------------
625| 322| }
626| |
627| | /* string parameters */
628| 2.07k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vx_stra); j++) {
------------------
| Branch (628:38): [True: 346, False: 1.72k]
------------------
629| 346| igraph_int_t idx = VECTOR(vx_stra)[j];
------------------
| | 60| 346|#define VECTOR(v) ((v).stor_begin)
------------------
630| 346| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 346| do { \
| | 657| 346| igraph_error_t igraph_i_ret = (expr); \
| | 658| 346| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 346| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 346]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 346| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 346]
| | ------------------
------------------
631| 346| graph, vstrnames[idx], igraph_vss_1(id), &strv));
632| 346| s = igraph_strvector_get(&strv, 0);
633| 346| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 346| do { \
| | 657| 346| igraph_error_t igraph_i_ret = (expr); \
| | 658| 346| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 346| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 346]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 346| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 346]
| | ------------------
------------------
634| 346| fprintf(outstream, " %s %s", vstrnames2[idx], escaped);
635| 346| IGRAPH_FREE(escaped);
------------------
| | 36| 346|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
636| 346| }
637| |
638| | /* trailing newline */
639| 1.72k| fprintf(outstream, "%s", newline);
640| 1.72k| }
641| 167| }
642| |
643| | /* edges header */
644| 3.34k| if (igraph_is_directed(graph)) {
------------------
| Branch (644:9): [True: 137, False: 3.20k]
------------------
645| 137| fprintf(outstream, "*Arcs%s", newline);
646| 3.20k| } else {
647| 3.20k| fprintf(outstream, "*Edges%s", newline);
648| 3.20k| }
649| |
650| 3.34k| IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_ID));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
651| 3.34k| IGRAPH_FINALLY(igraph_es_destroy, &es);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
652| 3.34k| IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
------------------
| | 656| 3.34k| do { \
| | 657| 3.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.34k]
| | ------------------
------------------
653| 3.34k| IGRAPH_FINALLY(igraph_eit_destroy, &eit);
------------------
| | 603| 3.34k| do { \
| | 604| 3.34k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.34k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.34k| * incorrect destructor function with the pointer */ \
| | 607| 3.34k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.34k]
| | ------------------
| | 608| 3.34k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.34k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.34k]
| | ------------------
------------------
654| |
655| | /* Check edge attributes */
656| | /* TODO: refactor and simplify since only "weight" is relevant */
657| 6.68k| for (igraph_int_t i = 0; i < E_LAST; i++) {
------------------
| | 266| 6.68k|#define E_LAST 1
------------------
| Branch (657:30): [True: 3.34k, False: 3.34k]
------------------
658| 3.34k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, enames[i])) {
------------------
| Branch (658:13): [True: 232, False: 3.10k]
------------------
659| 232| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 232| do { \
| | 657| 232| igraph_error_t igraph_i_ret = (expr); \
| | 658| 232| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 232| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 232]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 232| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 232]
| | ------------------
------------------
660| 232| graph, &etypes[i], IGRAPH_ATTRIBUTE_EDGE, enames[i]));
661| 3.10k| } else {
662| 3.10k| etypes[i] = (igraph_attribute_type_t) -1;
663| 3.10k| }
664| 3.34k| }
665| 50.1k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(enumnames) / sizeof(enumnames[0])); i++) {
------------------
| Branch (665:30): [True: 46.7k, False: 3.34k]
------------------
666| 46.7k| igraph_attribute_type_t type;
667| 46.7k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, enumnames[i])) {
------------------
| Branch (667:13): [True: 19, False: 46.7k]
------------------
668| 19| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 19| do { \
| | 657| 19| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19]
| | ------------------
------------------
669| 19| graph, &type, IGRAPH_ATTRIBUTE_EDGE, enumnames[i]));
670| 19| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (670:17): [True: 13, False: 6]
------------------
671| 13| IGRAPH_CHECK(igraph_vector_int_push_back(&ex_numa, i));
------------------
| | 656| 13| do { \
| | 657| 13| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 13| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13]
| | ------------------
------------------
672| 13| }
673| 19| }
674| 46.7k| }
675| 23.3k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(estrnames) / sizeof(estrnames[0])); i++) {
------------------
| Branch (675:30): [True: 20.0k, False: 3.34k]
------------------
676| 20.0k| igraph_attribute_type_t type;
677| 20.0k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, estrnames[i])) {
------------------
| Branch (677:13): [True: 131, False: 19.9k]
------------------
678| 131| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 131| do { \
| | 657| 131| igraph_error_t igraph_i_ret = (expr); \
| | 658| 131| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 131| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 131]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 131| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 131]
| | ------------------
------------------
679| 131| graph, &type, IGRAPH_ATTRIBUTE_EDGE, estrnames[i]));
680| 131| if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (680:17): [True: 109, False: 22]
------------------
681| 109| IGRAPH_CHECK(igraph_vector_int_push_back(&ex_stra, i));
------------------
| | 656| 109| do { \
| | 657| 109| igraph_error_t igraph_i_ret = (expr); \
| | 658| 109| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 109| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 109]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 109| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 109]
| | ------------------
------------------
682| 109| }
683| 131| }
684| 20.0k| }
685| |
686| 348k| for (igraph_int_t i = 0; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit), i++) {
------------------
| | 371| 348k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (igraph_int_t i = 0; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit), i++) {
------------------
| | 359| 344k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (686:30): [True: 344k, False: 3.34k]
------------------
687| 344k| igraph_int_t edge = IGRAPH_EIT_GET(eit);
------------------
| | 405| 344k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 344k, False: 0]
| | ------------------
| | 406| 344k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
688| 344k| igraph_int_t from, to;
689| |
690| 344k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 344k| do { \
| | 657| 344k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344k]
| | ------------------
------------------
691| 344k| if (bipartite) {
------------------
| Branch (691:13): [True: 385, False: 344k]
------------------
692| 385| from = VECTOR(bip_index2)[from];
------------------
| | 60| 385|#define VECTOR(v) ((v).stor_begin)
------------------
693| 385| to = VECTOR(bip_index2)[to];
------------------
| | 60| 385|#define VECTOR(v) ((v).stor_begin)
------------------
694| 385| }
695| 344k| fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId , from + 1, to + 1);
------------------
| | 63| 344k|# define IGRAPH_PRId PRId64
------------------
696| |
697| | /* Weights */
698| 344k| if (etypes[E_WEIGHT] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 265| 344k|#define E_WEIGHT 0
------------------
| Branch (698:13): [True: 94.7k, False: 250k]
------------------
699| 94.7k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 94.7k| do { \
| | 657| 94.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 94.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 94.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.7k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 94.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 94.7k]
| | ------------------
------------------
700| 94.7k| graph, enames[E_WEIGHT], igraph_ess_1(edge), &numv));
701| 94.7k| fputc(' ', outstream);
702| 94.7k| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 94.7k|#define VECTOR(v) ((v).stor_begin)
------------------
703| 94.7k| }
704| |
705| | /* numeric parameters */
706| 345k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&ex_numa); j++) {
------------------
| Branch (706:34): [True: 209, False: 344k]
------------------
707| 209| igraph_int_t idx = VECTOR(ex_numa)[j];
------------------
| | 60| 209|#define VECTOR(v) ((v).stor_begin)
------------------
708| 209| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 209| do { \
| | 657| 209| igraph_error_t igraph_i_ret = (expr); \
| | 658| 209| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 209| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 209]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 209| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 209]
| | ------------------
------------------
709| 209| graph, enumnames[idx], igraph_ess_1(edge), &numv));
710| 209| fprintf(outstream, " %s ", enumnames2[idx]);
711| 209| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 209|#define VECTOR(v) ((v).stor_begin)
------------------
712| 209| }
713| |
714| | /* string parameters */
715| 347k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&ex_stra); j++) {
------------------
| Branch (715:34): [True: 2.93k, False: 344k]
------------------
716| 2.93k| igraph_int_t idx = VECTOR(ex_stra)[j];
------------------
| | 60| 2.93k|#define VECTOR(v) ((v).stor_begin)
------------------
717| 2.93k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(
------------------
| | 656| 2.93k| do { \
| | 657| 2.93k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.93k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.93k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.93k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.93k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.93k]
| | ------------------
------------------
718| 2.93k| graph, estrnames[idx], igraph_ess_1(edge), &strv));
719| 2.93k| s = igraph_strvector_get(&strv, 0);
720| 2.93k| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 2.93k| do { \
| | 657| 2.93k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.93k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.93k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.93k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.93k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.93k]
| | ------------------
------------------
721| 2.93k| fprintf(outstream, " %s %s", estrnames2[idx], escaped);
722| 2.93k| IGRAPH_FREE(escaped);
------------------
| | 36| 2.93k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
723| 2.93k| }
724| |
725| | /* trailing newline */
726| 344k| fprintf(outstream, "%s", newline);
727| 344k| }
728| |
729| 3.34k| igraph_eit_destroy(&eit);
730| 3.34k| igraph_es_destroy(&es);
731| 3.34k| IGRAPH_FINALLY_CLEAN(2);
732| |
733| 3.34k| if (bipartite) {
------------------
| Branch (733:9): [True: 32, False: 3.30k]
------------------
734| 32| igraph_vector_int_destroy(&bip_index2);
735| 32| igraph_vector_int_destroy(&bip_index);
736| 32| IGRAPH_FINALLY_CLEAN(2);
737| 32| }
738| |
739| 3.34k| igraph_vector_int_destroy(&ex_numa);
740| 3.34k| igraph_vector_int_destroy(&ex_stra);
741| 3.34k| igraph_vector_int_destroy(&vx_numa);
742| 3.34k| igraph_vector_int_destroy(&vx_stra);
743| 3.34k| igraph_strvector_destroy(&strv);
744| 3.34k| igraph_vector_destroy(&numv);
745| 3.34k| IGRAPH_FINALLY_CLEAN(6);
746| 3.34k| return IGRAPH_SUCCESS;
747| 3.34k|}
pajek.c:pajek_escape:
270| 3.63k|static igraph_error_t pajek_escape(const char* src, char** dest) {
271| 3.63k| igraph_int_t destlen = 0;
272| 3.63k| igraph_bool_t need_escape = false;
273| |
274| | /* Determine whether the string contains characters to be escaped */
275| 3.63k| const char *s;
276| 3.63k| char *d;
277| 27.8M| for (s = src; *s; s++, destlen++) {
------------------
| Branch (277:19): [True: 27.8M, False: 3.63k]
------------------
278| 27.8M| if (*s == '\n' || *s == '\r') {
------------------
| Branch (278:13): [True: 744k, False: 27.1M]
| Branch (278:27): [True: 306, False: 27.1M]
------------------
279| 744k| need_escape = true;
280| 744k| destlen++;
281| 27.1M| } else if (*s == '"') {
------------------
| Branch (281:20): [True: 5.79M, False: 21.3M]
------------------
282| 5.79M| need_escape = true;
283| 5.79M| destlen += 4;
284| 21.3M| } else if (!isalnum(*s)) {
------------------
| Branch (284:20): [True: 12.2M, False: 9.03M]
------------------
285| 12.2M| need_escape = true;
286| 12.2M| }
287| 27.8M| }
288| |
289| 3.63k| if (!need_escape) {
------------------
| Branch (289:9): [True: 728, False: 2.90k]
------------------
290| | /* At this point, we know that the string does not contain any chars
291| | * that would warrant encoding. Therefore, we simply quote it and
292| | * return the quoted string. This is necessary because Pajek uses some
293| | * reserved words in its format (like 'c' standing for color) and they
294| | * have to be quoted as well.
295| | */
296| 728| *dest = IGRAPH_CALLOC(destlen + 3, char);
------------------
| | 33| 728|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.45k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 728, False: 0]
| | | | | Branch (31:24): [True: 728, False: 0]
| | | | | Branch (31:66): [True: 728, False: 0]
| | | | ------------------
| | ------------------
------------------
297| 728| CHECK_OOM_WP(*dest);
------------------
| | 44| 728|#define CHECK_OOM_WP(p) IGRAPH_CHECK_OOM((p), "Not enough memory to write Pajek format.")
| | ------------------
| | | | 709| 728| do { \
| | | | 710| 728| if (IGRAPH_UNLIKELY(!ptr)) { \
| | | | ------------------
| | | | | | 612| 728| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 728]
| | | | | | ------------------
| | | | ------------------
| | | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 712| 0| } \
| | | | 713| 728| } while (0)
| | | | ------------------
| | | | | Branch (713:14): [Folded, False: 728]
| | | | ------------------
| | ------------------
------------------
298| |
299| 728| d = *dest;
300| 728| strcpy(d + 1, src);
301| 728| d[0] = d[destlen + 1] = '"';
302| 728| d[destlen + 2] = 0;
303| 728| return IGRAPH_SUCCESS;
304| 728| }
305| |
306| 2.90k| *dest = IGRAPH_CALLOC(destlen + 3, char);
------------------
| | 33| 2.90k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 5.80k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 2.90k, False: 0]
| | | | | Branch (31:24): [True: 2.90k, False: 0]
| | | | | Branch (31:66): [True: 2.90k, False: 0]
| | | | ------------------
| | ------------------
------------------
307| 2.90k| CHECK_OOM_WP(*dest);
------------------
| | 44| 2.90k|#define CHECK_OOM_WP(p) IGRAPH_CHECK_OOM((p), "Not enough memory to write Pajek format.")
| | ------------------
| | | | 709| 2.90k| do { \
| | | | 710| 2.90k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | | | ------------------
| | | | | | 612| 2.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 2.90k]
| | | | | | ------------------
| | | | ------------------
| | | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 712| 0| } \
| | | | 713| 2.90k| } while (0)
| | | | ------------------
| | | | | Branch (713:14): [Folded, False: 2.90k]
| | | | ------------------
| | ------------------
------------------
308| |
309| 2.90k| d = *dest;
310| 2.90k| *d = '"'; d++;
311| |
312| 27.1M| for (s = src; *s; s++, d++) {
------------------
| Branch (312:19): [True: 27.1M, False: 2.90k]
------------------
313| 27.1M| switch (*s) {
314| | /* Encode quotation marks as ", as they would otherwise signify
315| | the end/beginning of a string. */
316| 5.79M| case '"':
------------------
| Branch (316:9): [True: 5.79M, False: 21.3M]
------------------
317| 5.79M| strcpy(d, """); d += 4; break;
318| 0| break;
319| | /* Encode both CR and LF as \n, as neither should apear in a quoted string.
320| | \n is the _only_ escape sequence Pajek understands. */
321| 744k| case '\n':
------------------
| Branch (321:9): [True: 744k, False: 26.3M]
------------------
322| 744k| case '\r':
------------------
| Branch (322:9): [True: 306, False: 27.1M]
------------------
323| 744k| *d = '\\'; d++;
324| 744k| *d = 'n';
325| 744k| break;
326| 20.5M| default:
------------------
| Branch (326:9): [True: 20.5M, False: 6.54M]
------------------
327| 20.5M| *d = *s;
328| 27.1M| }
329| 27.1M| }
330| 2.90k| *d = '"'; d++; *d = 0;
331| |
332| 2.90k| return IGRAPH_SUCCESS;
333| 2.90k|}
igraph_i_trim_whitespace:
33| 19.6k|void igraph_i_trim_whitespace(const char *str, size_t str_len, const char **res, size_t *res_len) {
34| 19.6k| const char *beg = str, *end = str + str_len;
35| 41.1k| while (beg < end && isspace(beg[0]) ) beg++;
------------------
| Branch (35:12): [True: 40.4k, False: 699]
| Branch (35:25): [True: 21.4k, False: 18.9k]
------------------
36| 21.1k| while (end > beg && isspace(end[-1])) end--;
------------------
| Branch (36:12): [True: 20.4k, False: 699]
| Branch (36:25): [True: 1.49k, False: 18.9k]
------------------
37| 19.6k| *res = beg;
38| 19.6k| *res_len = end - beg;
39| 19.6k|}
igraph_i_parse_integer:
52| 807|igraph_error_t igraph_i_parse_integer(const char *str, size_t length, igraph_int_t *value) {
53| 807| char buffer[128];
54| 807| char *tmp, *end;
55| 807| char last_char;
56| 807| igraph_bool_t out_of_range, dynamic_alloc;
57| 807| long long val;
58| |
59| 807| if (length == 0) {
------------------
| Branch (59:9): [True: 0, False: 807]
------------------
60| 0| IGRAPH_ERROR("Cannot parse integer from empty string.", IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
61| 0| }
62| |
63| 807| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]);
64| |
65| 807| if (dynamic_alloc) {
------------------
| Branch (65:9): [True: 17, False: 790]
------------------
66| 17| tmp = IGRAPH_CALLOC(length+1, char);
------------------
| | 33| 17|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 34| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 17, False: 0]
| | | | | Branch (31:24): [True: 17, False: 0]
| | | | | Branch (31:66): [True: 17, False: 0]
| | | | ------------------
| | ------------------
------------------
67| 17| IGRAPH_CHECK_OOM(tmp, "Failed to parse integer.");
------------------
| | 709| 17| do { \
| | 710| 17| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 17| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 17| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 17]
| | ------------------
------------------
68| 790| } else {
69| 790| tmp = buffer;
70| 790| }
71| |
72| 807| strncpy(tmp, str, length);
73| 807| tmp[length]='\0';
74| |
75| | /* To avoid having to choose the appropriate strto?() function based on
76| | * the definition of igraph_int_t, we first use a long long variable
77| | * which should be at least as large as igraph_int_t on any platform. */
78| 807| errno = 0;
79| 807| val = strtoll(tmp, &end, 10);
80| 807| out_of_range = errno == ERANGE;
81| 807| *value = (igraph_int_t) val;
82| 807| last_char = *end;
83| 807| if (*value != val) {
------------------
| Branch (83:9): [True: 0, False: 807]
------------------
84| 0| out_of_range = true;
85| 0| }
86| |
87| | /* Free memory before raising any errors. */
88| 807| if (dynamic_alloc) {
------------------
| Branch (88:9): [True: 17, False: 790]
------------------
89| 17| IGRAPH_FREE(tmp);
------------------
| | 36| 17|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
90| 17| }
91| |
92| 807| if (out_of_range) {
------------------
| Branch (92:9): [True: 1, False: 806]
------------------
93| 1| IGRAPH_ERROR("Failed to parse integer.", val > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW);
------------------
| | 426| 1| do { \
| | 427| 2| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | ------------------
| | | Branch (427:63): [True: 1, False: 0]
| | ------------------
| | 428| 2| return igraph_errno ; \
| | ------------------
| | | Branch (428:16): [True: 1, False: 0]
| | ------------------
| | 429| 1| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
94| 1| }
95| |
96| | /* Did we parse to the end of the string? */
97| 806| if (last_char) {
------------------
| Branch (97:9): [True: 26, False: 780]
------------------
98| 26| IGRAPH_ERRORF("Unexpected character '%c' while parsing integer.", IGRAPH_PARSEERROR, last_char);
------------------
| | 464| 26| do { \
| | 465| 26| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 26| igraph_errno, __VA_ARGS__) ; \
| | 467| 26| return igraph_errno; \
| | 468| 26| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
99| 26| }
100| |
101| 780| return IGRAPH_SUCCESS;
102| 806|}
igraph_i_parse_real:
113| 940k|igraph_error_t igraph_i_parse_real(const char *str, size_t length, igraph_real_t *value) {
114| 940k| char buffer[128];
115| 940k| char *tmp, *end;
116| 940k| char last_char;
117| 940k| igraph_bool_t out_of_range, dynamic_alloc;
118| |
119| 940k| if (length == 0) {
------------------
| Branch (119:9): [True: 0, False: 940k]
------------------
120| 0| IGRAPH_ERROR("Cannot parse real number from empty string.", IGRAPH_PARSEERROR);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
121| 0| }
122| |
123| 940k| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]);
124| |
125| 940k| if (dynamic_alloc) {
------------------
| Branch (125:9): [True: 207, False: 940k]
------------------
126| 207| tmp = IGRAPH_CALLOC(length+1, char);
------------------
| | 33| 207|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 414| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 207, False: 0]
| | | | | Branch (31:24): [True: 207, False: 0]
| | | | | Branch (31:66): [True: 207, False: 0]
| | | | ------------------
| | ------------------
------------------
127| 207| IGRAPH_CHECK_OOM(tmp, "Failed to parse real number.");
------------------
| | 709| 207| do { \
| | 710| 207| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 207| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 207]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 207| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 207]
| | ------------------
------------------
128| 940k| } else {
129| 940k| tmp = buffer;
130| 940k| }
131| |
132| 940k| strncpy(tmp, str, length);
133| 940k| tmp[length]='\0';
134| |
135| 940k| errno = 0;
136| 940k| *value = strtod(tmp, &end);
137| 940k| out_of_range = errno == ERANGE; /* This does not trigger when reading +-Inf. */
138| 940k| last_char = *end;
139| |
140| | /* Free memory before raising any errors. */
141| 940k| if (dynamic_alloc) {
------------------
| Branch (141:9): [True: 207, False: 940k]
------------------
142| 207| IGRAPH_FREE(tmp);
------------------
| | 36| 207|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
143| 207| }
144| |
145| 940k| if (out_of_range) {
------------------
| Branch (145:9): [True: 1, False: 940k]
------------------
146| 1| IGRAPH_ERROR("Failed to parse real number.", *value > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW);
------------------
| | 426| 1| do { \
| | 427| 2| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | ------------------
| | | Branch (427:63): [True: 1, False: 0]
| | ------------------
| | 428| 2| return igraph_errno ; \
| | ------------------
| | | Branch (428:16): [True: 1, False: 0]
| | ------------------
| | 429| 1| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
147| 1| }
148| |
149| | /* Did we parse to the end of the string? */
150| 940k| if (last_char) {
------------------
| Branch (150:9): [True: 19, False: 940k]
------------------
151| 19| IGRAPH_ERRORF("Unexpected character '%c' while parsing real number.", IGRAPH_PARSEERROR, last_char);
------------------
| | 464| 19| do { \
| | 465| 19| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 19| igraph_errno, __VA_ARGS__) ; \
| | 467| 19| return igraph_errno; \
| | 468| 19| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
152| 19| }
153| |
154| 940k| return IGRAPH_SUCCESS;
155| 940k|}
igraph_i_is_real_representable_as_integer:
111| 745k|igraph_bool_t igraph_i_is_real_representable_as_integer(igraph_real_t value) {
112| | /* IGRAPH_INTEGER_MAX is one less than a power of 2, and may not be representable as
113| | * a floating point number. Thus we cannot safely check that value <= IGRAPH_INTEGER_MAX,
114| | * as this would convert IGRAPH_INTEGER_MAX to floating point, potentially changing its value.
115| | * Instead, we compute int_max_plus_1 = IGRAPH_INTEGER_MAX + 1, which is exactly representable
116| | * since it is a power of 2, and check that value < int_max_plus_1.
117| | *
118| | * IGRAPH_INTEGER_MIN is a power of 2 (with negative sign), so there is no such issue.
119| | *
120| | * NaNs and infinities are correctly rejected.
121| | */
122| 745k| const igraph_real_t int_max_plus_1 = 2.0 * (IGRAPH_INTEGER_MAX / 2 + 1);
------------------
| | 72| 745k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
123| 745k| const igraph_real_t int_min = (igraph_real_t) IGRAPH_INTEGER_MIN;
------------------
| | 73| 745k|# define IGRAPH_INTEGER_MIN INT64_MIN
------------------
124| 745k| if (IGRAPH_LIKELY(int_min <= value && value < int_max_plus_1)) {
------------------
| | 613| 1.49M| #define IGRAPH_LIKELY(a) __builtin_expect(!!(a), 1)
| | ------------------
| | | Branch (613:32): [True: 745k, False: 222]
| | | Branch (613:52): [True: 745k, False: 194]
| | | Branch (613:52): [True: 745k, False: 28]
| | ------------------
------------------
125| 745k| return true;
126| 745k| } else {
127| | return false;
128| 222| }
129| 745k|}