igraph_gml_yylex:
1027| 3.40M|{
1028| 3.40M| yy_state_type yy_current_state;
1029| 3.40M| char *yy_cp, *yy_bp;
1030| 3.40M| int yy_act;
1031| 3.40M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1032| |
1033| 3.40M| yylval = yylval_param;
------------------
| | 837| 3.40M| # define yylval yyg->yylval_r
------------------
1034| |
1035| 3.40M| yylloc = yylloc_param;
------------------
| | 839| 3.40M| # define yylloc yyg->yylloc_r
------------------
1036| |
1037| 3.40M| if ( !yyg->yy_init )
------------------
| Branch (1037:7): [True: 3.17k, False: 3.40M]
------------------
1038| 3.17k| {
1039| 3.17k| yyg->yy_init = 1;
1040| |
1041| |#ifdef YY_USER_INIT
1042| | YY_USER_INIT;
1043| |#endif
1044| |
1045| 3.17k| if ( ! yyg->yy_start )
------------------
| Branch (1045:8): [True: 3.17k, False: 0]
------------------
1046| 3.17k| yyg->yy_start = 1; /* first start state */
1047| |
1048| 3.17k| if ( ! yyin )
------------------
| | 356| 3.17k|#define yyin yyg->yyin_r
------------------
| Branch (1048:8): [True: 0, False: 3.17k]
------------------
1049| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1050| |
1051| 3.17k| if ( ! yyout )
------------------
| | 357| 3.17k|#define yyout yyg->yyout_r
------------------
| Branch (1051:8): [True: 3.17k, False: 0]
------------------
1052| 3.17k| yyout = stdout;
------------------
| | 357| 3.17k|#define yyout yyg->yyout_r
------------------
1053| |
1054| 3.17k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.17k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.17k]
| | ------------------
| | 522| 3.17k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.17k| : NULL)
------------------
| Branch (1054:8): [True: 3.17k, False: 0]
------------------
1055| 3.17k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.17k|#define yyensure_buffer_stack igraph_gml_yyensure_buffer_stack
------------------
1056| 3.17k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1057| 3.17k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.17k|#define yy_create_buffer igraph_gml_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.17k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.17k|#define YY_BUF_SIZE 16384
------------------
1058| 3.17k| }
1059| |
1060| 3.17k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.17k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1061| 3.17k| }
1062| |
1063| 3.40M| {
1064| 3.40M|#line 80 "/src/igraph/src/io/gml-lexer.l"
1065| |
1066| |
1067| 3.40M|#line 1068 "/src/igraph/build/src/io/parsers/gml-lexer.c"
1068| |
1069| 9.08M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1069:23): [True: 9.08M, Folded]
------------------
1070| 9.08M| {
1071| 9.08M| yy_cp = yyg->yy_c_buf_p;
1072| |
1073| | /* Support of yytext. */
1074| 9.08M| *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| 9.08M| yy_bp = yy_cp;
1080| |
1081| 9.08M| yy_current_state = yyg->yy_start;
1082| 9.08M| yy_current_state += YY_AT_BOL();
------------------
| | 569| 9.08M|#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
| | ------------------
| | | | 527| 9.08M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1083| 9.11M|yy_match:
1084| 9.11M| do
1085| 216M| {
1086| 216M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 216M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1087| 216M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1087:9): [True: 41.1M, False: 175M]
------------------
1088| 41.1M| {
1089| 41.1M| yyg->yy_last_accepting_state = yy_current_state;
1090| 41.1M| yyg->yy_last_accepting_cpos = yy_cp;
1091| 41.1M| }
1092| 426M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1092:12): [True: 209M, False: 216M]
------------------
1093| 209M| {
1094| 209M| yy_current_state = (int) yy_def[yy_current_state];
1095| 209M| if ( yy_current_state >= 43 )
------------------
| Branch (1095:10): [True: 196M, False: 13.6M]
------------------
1096| 196M| yy_c = yy_meta[yy_c];
1097| 209M| }
1098| 216M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1099| 216M| ++yy_cp;
1100| 216M| }
1101| 216M| while ( yy_base[yy_current_state] != 85 );
------------------
| Branch (1101:11): [True: 207M, False: 9.11M]
------------------
1102| |
1103| 9.11M|yy_find_action:
1104| 9.11M| yy_act = yy_accept[yy_current_state];
1105| 9.11M| if ( yy_act == 0 )
------------------
| Branch (1105:8): [True: 7.97M, False: 1.14M]
------------------
1106| 7.97M| { /* have to back up */
1107| 7.97M| yy_cp = yyg->yy_last_accepting_cpos;
1108| 7.97M| yy_current_state = yyg->yy_last_accepting_state;
1109| 7.97M| yy_act = yy_accept[yy_current_state];
1110| 7.97M| }
1111| |
1112| 9.11M| YY_DO_BEFORE_ACTION;
------------------
| | 590| 9.11M| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 9.11M|#define yytext_ptr yytext_r
| | ------------------
| | 591| 9.11M| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 9.11M|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 9.11M| yyg->yy_hold_char = *yy_cp; \
| | 593| 9.11M| *yy_cp = '\0'; \
| | 594| 9.11M| yyg->yy_c_buf_p = yy_cp;
------------------
1113| |
1114| 9.11M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 18.2M|#define YY_END_OF_BUFFER 12
------------------
| Branch (1114:8): [True: 9.08M, False: 35.5k]
| Branch (1114:38): [True: 2.64M, False: 6.43M]
------------------
1115| 2.64M| {
1116| 2.64M| int yyl;
1117| 171M| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 171M|#define yyleng yyg->yyleng_r
------------------
| Branch (1117:19): [True: 169M, False: 2.64M]
------------------
1118| 169M| if ( yytext[yyl] == '\n' )
------------------
| | 360| 169M|#define yytext yyg->yytext_r
------------------
| Branch (1118:10): [True: 14.4M, False: 154M]
------------------
1119| |
1120| 14.4M| do{ yylineno++;
------------------
| | 361| 14.4M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 14.4M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1121| 14.4M| yycolumn=0;
------------------
| | 362| 14.4M|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 14.4M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1122| 14.4M| }while(0)
------------------
| Branch (1122:12): [Folded, False: 14.4M]
------------------
1123| 2.64M|;
1124| 2.64M| }
1125| |
1126| 9.12M|do_action: /* This label is used only to access EOF actions. */
1127| |
1128| 9.12M| switch ( yy_act )
1129| 9.12M| { /* beginning of action switch */
1130| 0| case 0: /* must back up */
------------------
| Branch (1130:4): [True: 0, False: 9.12M]
------------------
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.12M]
------------------
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| 362k|case 2:
------------------
| Branch (1142:1): [True: 362k, False: 8.75M]
------------------
1143| |/* rule 2 can match eol */
1144| 362k|YY_RULE_SETUP
------------------
| | 1019| 362k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 362k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 362k, False: 0]
| | ------------------
| | 1020| 362k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 362k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 362k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 362k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 362k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 362k| YY_USER_ACTION
| | ------------------
| | | | 764| 362k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 362k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 362k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 362k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1145| 362k|#line 84 "/src/igraph/src/io/gml-lexer.l"
1146| 362k|{ BEGIN(INITIAL); return STRING; }
------------------
| | 369| 362k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return STRING; }
------------------
| | 780| 362k|#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.12M]
------------------
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| 757k|case 4:
------------------
| Branch (1153:1): [True: 757k, False: 8.36M]
------------------
1154| 757k|YY_RULE_SETUP
------------------
| | 1019| 757k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 757k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 757k, False: 0]
| | ------------------
| | 1020| 757k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 757k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 757k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 757k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 757k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 757k| YY_USER_ACTION
| | ------------------
| | | | 764| 757k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 757k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 757k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 757k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1155| 757k|#line 86 "/src/igraph/src/io/gml-lexer.l"
1156| 757k|{ BEGIN(INITIAL); return NUM; }
------------------
| | 369| 757k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NUM; }
------------------
| | 780| 757k|#define INITIAL 0
------------------
1157| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1158| 1.50M|case 5:
------------------
| Branch (1158:1): [True: 1.50M, False: 7.61M]
------------------
1159| 1.50M|YY_RULE_SETUP
------------------
| | 1019| 1.50M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 1.50M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 1.50M, False: 0]
| | ------------------
| | 1020| 1.50M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 1.50M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 1.50M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 1.50M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 1.50M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 1.50M| YY_USER_ACTION
| | ------------------
| | | | 764| 1.50M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 1.50M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 1.50M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 1.50M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1160| 1.50M|#line 87 "/src/igraph/src/io/gml-lexer.l"
1161| 1.50M|{ BEGIN(VALUE); return KEYWORD; }
------------------
| | 369| 1.50M|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(VALUE); return KEYWORD; }
------------------
| | 781| 1.50M|#define VALUE 1
------------------
1162| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1163| 388k|case 6:
------------------
| Branch (1163:1): [True: 388k, False: 8.73M]
------------------
1164| 388k|YY_RULE_SETUP
------------------
| | 1019| 388k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 388k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 388k, False: 0]
| | ------------------
| | 1020| 388k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 388k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 388k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 388k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 388k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 388k| YY_USER_ACTION
| | ------------------
| | | | 764| 388k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 388k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 388k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 388k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1165| 388k|#line 88 "/src/igraph/src/io/gml-lexer.l"
1166| 388k|{
1167| 388k| BEGIN(INITIAL);
------------------
| | 369| 388k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
BEGIN(INITIAL);
------------------
| | 780| 388k|#define INITIAL 0
------------------
1168| 388k| yyextra->depth++;
------------------
| | 358| 388k|#define yyextra yyg->yyextra_r
------------------
1169| 388k| if (yyextra->depth >= 32) {
------------------
| | 358| 388k|#define yyextra yyg->yyextra_r
------------------
| Branch (1169:31): [True: 0, False: 388k]
------------------
1170| 0| return ERROR;
1171| 388k| } else {
1172| 388k| return LISTOPEN;
1173| 388k| }
1174| 388k| }
1175| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1176| 388k|case 7:
------------------
| Branch (1176:1): [True: 388k, False: 8.73M]
------------------
1177| 388k|YY_RULE_SETUP
------------------
| | 1019| 388k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 388k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 388k, False: 0]
| | ------------------
| | 1020| 388k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 388k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 388k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 388k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 388k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 388k| YY_USER_ACTION
| | ------------------
| | | | 764| 388k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 388k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 388k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 388k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1178| 388k|#line 97 "/src/igraph/src/io/gml-lexer.l"
1179| 388k|{
1180| 388k| yyextra->depth--;
------------------
| | 358| 388k|#define yyextra yyg->yyextra_r
------------------
1181| 388k| return LISTCLOSE;
1182| 388k| }
1183| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1184| 3.39M|case 8:
------------------
| Branch (1184:1): [True: 3.39M, False: 5.73M]
------------------
1185| 3.39M|YY_RULE_SETUP
------------------
| | 1019| 3.39M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 3.39M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 3.39M, False: 0]
| | ------------------
| | 1020| 3.39M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 3.39M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 3.39M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 3.39M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 3.39M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 3.39M| YY_USER_ACTION
| | ------------------
| | | | 764| 3.39M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 3.39M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 3.39M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 3.39M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1186| 3.39M|#line 101 "/src/igraph/src/io/gml-lexer.l"
1187| 3.39M|{ /* other whitespace ignored */ }
1188| 3.39M| YY_BREAK
------------------
| | 1015| 3.39M|#define YY_BREAK /*LINTED*/break;
------------------
1189| 2.28M|case 9:
------------------
| Branch (1189:1): [True: 2.28M, False: 6.83M]
------------------
1190| |/* rule 9 can match eol */
1191| 2.28M|YY_RULE_SETUP
------------------
| | 1019| 2.28M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 2.28M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 2.28M, False: 0]
| | ------------------
| | 1020| 2.28M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 2.28M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 2.28M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 2.28M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 2.28M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 2.28M| YY_USER_ACTION
| | ------------------
| | | | 764| 2.28M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 2.28M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 2.28M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 2.28M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1192| 2.28M|#line 102 "/src/igraph/src/io/gml-lexer.l"
1193| 2.28M|{ yy_set_bol(true); /* set "beginning of line" even after \r */ }
------------------
| | 561| 2.28M| { \
| | 562| 2.28M| if ( ! YY_CURRENT_BUFFER ){\
| | ------------------
| | | | 521| 2.28M|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | | | ------------------
| | | | | Branch (521:29): [True: 2.28M, False: 0]
| | | | ------------------
| | | | 522| 2.28M| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | | | 523| 2.28M| : NULL)
| | ------------------
| | | Branch (562:7): [True: 0, False: 2.28M]
| | ------------------
| | 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.28M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
| | ------------------
| | | | 527| 2.28M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 568| 2.28M| }
------------------
1194| 2.28M| YY_BREAK
------------------
| | 1015| 2.28M|#define YY_BREAK /*LINTED*/break;
------------------
1195| 0|case 10:
------------------
| Branch (1195:1): [True: 0, False: 9.12M]
------------------
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.12M]
------------------
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.17k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.17k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.17k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
| Branch (1206:1): [True: 3.17k, False: 9.11M]
------------------
1207| 3.17k|case YY_STATE_EOF(VALUE):
------------------
| | 377| 3.17k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.17k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
| Branch (1207:1): [True: 0, False: 9.12M]
------------------
1208| 3.17k| yyterminate();
------------------
| | 978| 3.17k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.17k|#define YY_NULL 0
| | ------------------
------------------
1209| |
1210| 35.5k| case YY_END_OF_BUFFER:
------------------
| | 596| 35.5k|#define YY_END_OF_BUFFER 12
------------------
| Branch (1210:2): [True: 35.5k, False: 9.08M]
------------------
1211| 35.5k| {
1212| | /* Amount of text matched not including the EOB char. */
1213| 35.5k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 35.5k|#define yytext_ptr yytext_r
------------------
1214| |
1215| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1216| 35.5k| *yy_cp = yyg->yy_hold_char;
1217| 35.5k| YY_RESTORE_YY_MORE_OFFSET
1218| |
1219| 35.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 35.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| 35.5k|#define YY_BUFFER_NEW 0
------------------
| Branch (1219:8): [True: 3.17k, False: 32.4k]
------------------
1220| 3.17k| {
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.17k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1231| 3.17k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.17k|#define yyin yyg->yyin_r
------------------
1232| 3.17k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.17k|#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.17k|#define YY_BUFFER_NORMAL 1
------------------
1233| 3.17k| }
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.5k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 35.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1242:8): [True: 0, False: 35.5k]
------------------
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.5k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1278:17): [True: 35.5k, False: 0]
------------------
1279| 35.5k| {
1280| 3.17k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.17k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1280:4): [True: 3.17k, False: 32.4k]
------------------
1281| 3.17k| {
1282| 3.17k| yyg->yy_did_buffer_switch_on_eof = 0;
1283| |
1284| 3.17k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.17k|#define yywrap igraph_gml_yywrap
| | ------------------
| | | | 573| 3.17k|#define igraph_gml_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:38): [True: 3.17k, Folded]
| | | | ------------------
| | ------------------
------------------
1285| 3.17k| {
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.17k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.17k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 3.17k|#define YY_MORE_ADJ 0
------------------
1296| |
1297| 3.17k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.17k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.17k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
1298| 3.17k| goto do_action;
1299| 3.17k| }
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.17k| }
1308| |
1309| 29.2k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 29.2k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1309:4): [True: 29.2k, False: 6.35k]
------------------
1310| 29.2k| yyg->yy_c_buf_p =
1311| 29.2k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 29.2k|#define yytext_ptr yytext_r
------------------
1312| |
1313| 29.2k| yy_current_state = yy_get_previous_state( yyscanner );
1314| |
1315| 29.2k| yy_cp = yyg->yy_c_buf_p;
1316| 29.2k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 29.2k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 29.2k|#define YY_MORE_ADJ 0
------------------
1317| 29.2k| goto yy_match;
1318| |
1319| 3.17k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 3.17k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1319:4): [True: 3.17k, False: 32.4k]
------------------
1320| 3.17k| yyg->yy_c_buf_p =
1321| 3.17k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 3.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1322| |
1323| 3.17k| yy_current_state = yy_get_previous_state( yyscanner );
1324| |
1325| 3.17k| yy_cp = yyg->yy_c_buf_p;
1326| 3.17k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.17k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 3.17k|#define YY_MORE_ADJ 0
------------------
1327| 3.17k| goto yy_find_action;
1328| 35.5k| }
1329| 0| break;
1330| 35.5k| }
1331| |
1332| 0| default:
------------------
| Branch (1332:2): [True: 0, False: 9.12M]
------------------
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.12M| "fatal flex scanner internal error--no action found" );
1335| 9.12M| } /* end of action switch */
1336| 9.12M| } /* end of scanning one token */
1337| 3.40M| } /* end of user's declarations */
1338| 3.40M|} /* end of yylex */
igraph_gml_yyrestart:
1638| 3.17k|{
1639| 3.17k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1640| |
1641| 3.17k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.17k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.17k, False: 0]
| | ------------------
| | 522| 3.17k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.17k| : NULL)
------------------
| Branch (1641:7): [True: 0, False: 3.17k]
------------------
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.17k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.17k|#define yy_init_buffer igraph_gml_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.17k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.17k, False: 0]
| | ------------------
| | 522| 3.17k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.17k| : NULL)
------------------
1648| 3.17k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.17k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1649| 3.17k|}
igraph_gml_yy_create_buffer:
1703| 3.17k|{
1704| 3.17k| YY_BUFFER_STATE b;
1705| |
1706| 3.17k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.17k|#define yyalloc igraph_gml_yyalloc
------------------
1707| 3.17k| if ( ! b )
------------------
| Branch (1707:7): [True: 0, False: 3.17k]
------------------
1708| 3.17k| 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.17k| 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.17k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.17k|#define yyalloc igraph_gml_yyalloc
------------------
1716| 3.17k| if ( ! b->yy_ch_buf )
------------------
| Branch (1716:7): [True: 0, False: 3.17k]
------------------
1717| 3.17k| 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.17k| b->yy_is_our_buffer = 1;
1720| |
1721| 3.17k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.17k|#define yy_init_buffer igraph_gml_yy_init_buffer
------------------
1722| |
1723| 3.17k| return b;
1724| 3.17k|}
igraph_gml_yy_delete_buffer:
1731| 3.17k|{
1732| 3.17k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1733| |
1734| 3.17k| if ( ! b )
------------------
| Branch (1734:7): [True: 0, False: 3.17k]
------------------
1735| 0| return;
1736| |
1737| 3.17k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.17k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.17k, False: 0]
| | ------------------
| | 522| 3.17k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.17k| : NULL)
------------------
| Branch (1737:7): [True: 3.17k, False: 0]
------------------
1738| 3.17k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1739| |
1740| 3.17k| if ( b->yy_is_our_buffer )
------------------
| Branch (1740:7): [True: 3.17k, False: 0]
------------------
1741| 3.17k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.17k|#define yyfree igraph_gml_yyfree
------------------
1742| |
1743| 3.17k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.17k|#define yyfree igraph_gml_yyfree
------------------
1744| 3.17k|}
igraph_gml_yy_flush_buffer:
1780| 6.35k|{
1781| 6.35k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1782| 6.35k| if ( ! b )
------------------
| Branch (1782:7): [True: 0, False: 6.35k]
------------------
1783| 0| return;
1784| |
1785| 6.35k| 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.35k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.35k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1792| 6.35k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.35k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1793| |
1794| 6.35k| b->yy_buf_pos = &b->yy_ch_buf[0];
1795| |
1796| 6.35k| b->yy_at_bol = 1;
1797| 6.35k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 6.35k|#define YY_BUFFER_NEW 0
------------------
1798| |
1799| 6.35k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 6.35k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.35k, False: 0]
| | ------------------
| | 522| 6.35k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.35k| : NULL)
------------------
| Branch (1799:7): [True: 3.17k, False: 3.17k]
------------------
1800| 3.17k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.17k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1801| 6.35k|}
igraph_gml_yypop_buffer_state:
1841| 3.17k|{
1842| 3.17k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1843| 3.17k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.17k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.17k, False: 0]
| | ------------------
| | 522| 3.17k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.17k| : NULL)
------------------
| Branch (1843:6): [True: 3.17k, False: 0]
------------------
1844| 3.17k| 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.62M|{
2079| 2.62M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2080| 2.62M| return yyleng;
------------------
| | 359| 2.62M|#define yyleng yyg->yyleng_r
------------------
2081| 2.62M|}
igraph_gml_yyget_text:
2088| 2.62M|{
2089| 2.62M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2090| 2.62M| return yytext;
------------------
| | 360| 2.62M|#define yytext yyg->yytext_r
------------------
2091| 2.62M|}
igraph_gml_yyset_extra:
2098| 6.35k|{
2099| 6.35k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2100| 6.35k| yyextra = user_defined ;
------------------
| | 358| 6.35k|#define yyextra yyg->yyextra_r
------------------
2101| 6.35k|}
igraph_gml_yyset_in:
2140| 3.17k|{
2141| 3.17k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2142| 3.17k| yyin = _in_str ;
------------------
| | 356| 3.17k|#define yyin yyg->yyin_r
------------------
2143| 3.17k|}
igraph_gml_yylex_init_extra:
2223| 3.17k|{
2224| 3.17k| struct yyguts_t dummy_yyguts;
2225| |
2226| 3.17k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.17k|#define yyset_extra igraph_gml_yyset_extra
------------------
2227| |
2228| 3.17k| if (ptr_yy_globals == NULL){
------------------
| Branch (2228:9): [True: 0, False: 3.17k]
------------------
2229| 0| errno = EINVAL;
2230| 0| return 1;
2231| 0| }
2232| |
2233| 3.17k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.17k|#define yyalloc igraph_gml_yyalloc
------------------
2234| |
2235| 3.17k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2235:9): [True: 0, False: 3.17k]
------------------
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.17k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2243| |
2244| 3.17k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.17k|#define yyset_extra igraph_gml_yyset_extra
------------------
2245| |
2246| 3.17k| return yy_init_globals ( *ptr_yy_globals );
2247| 3.17k|}
igraph_gml_yylex_destroy:
2284| 3.17k|{
2285| 3.17k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2286| |
2287| | /* Pop the buffer stack, destroying each element. */
2288| 6.35k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 6.35k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.17k, False: 3.17k]
| | | Branch (521:29): [True: 6.35k, False: 0]
| | ------------------
| | 522| 6.35k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.35k| : NULL)
------------------
2289| 3.17k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.17k|#define yy_delete_buffer igraph_gml_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.17k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.17k, False: 0]
| | ------------------
| | 522| 3.17k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.17k| : NULL)
------------------
2290| 3.17k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2291| 3.17k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.17k|#define yypop_buffer_state igraph_gml_yypop_buffer_state
------------------
2292| 3.17k| }
2293| |
2294| | /* Destroy the stack itself. */
2295| 3.17k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.17k|#define yyfree igraph_gml_yyfree
------------------
2296| 3.17k| yyg->yy_buffer_stack = NULL;
2297| |
2298| | /* Destroy the start condition stack. */
2299| 3.17k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.17k|#define yyfree igraph_gml_yyfree
------------------
2300| 3.17k| 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.17k| yy_init_globals( yyscanner);
2305| |
2306| | /* Destroy the main struct (reentrant only). */
2307| 3.17k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.17k|#define yyfree igraph_gml_yyfree
------------------
2308| | yyscanner = NULL;
2309| 3.17k| return 0;
2310| 3.17k|}
igraph_gml_yyalloc:
2340| 12.7k|{
2341| 12.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2342| 12.7k| (void)yyg;
2343| 12.7k| return malloc(size);
2344| 12.7k|}
igraph_gml_yyrealloc:
2347| 494|{
2348| 494| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2349| 494| (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| 494| return realloc(ptr, size);
2359| 494|}
igraph_gml_yyfree:
2362| 15.8k|{
2363| 15.8k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2364| 15.8k| (void)yyg;
2365| 15.8k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2366| 15.8k|}
gml-lexer.c:yy_get_next_buffer:
1348| 35.5k|{
1349| 35.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1350| 35.5k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 35.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1351| 35.5k| char *source = yyg->yytext_ptr;
------------------
| | 579| 35.5k|#define yytext_ptr yytext_r
------------------
1352| 35.5k| int number_to_move, i;
1353| 35.5k| int ret_val;
1354| |
1355| 35.5k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 35.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1355:7): [True: 0, False: 35.5k]
------------------
1356| 35.5k| 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.5k| "fatal flex scanner internal error--end of buffer missed" );
1358| |
1359| 35.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 35.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1359:7): [True: 0, False: 35.5k]
------------------
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.5k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 35.5k|#define yytext_ptr yytext_r
------------------
1382| |
1383| 2.09G| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1383:15): [True: 2.09G, False: 35.5k]
------------------
1384| 2.09G| *(dest++) = *(source++);
1385| |
1386| 35.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 35.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| 35.5k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1386:7): [True: 3.17k, False: 32.4k]
------------------
1387| | /* don't do the read, it's not guaranteed to return an EOF,
1388| | * just force an EOF
1389| | */
1390| 3.17k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 3.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1391| |
1392| 32.4k| else
1393| 32.4k| {
1394| 32.4k| int num_to_read =
1395| 32.4k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 32.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1396| |
1397| 32.9k| while ( num_to_read <= 0 )
------------------
| Branch (1397:11): [True: 494, False: 32.4k]
------------------
1398| 494| { /* Not enough room in the buffer - grow it. */
1399| |
1400| | /* just a shorter name for the current buffer */
1401| 494| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 494|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1402| |
1403| 494| int yy_c_buf_p_offset =
1404| 494| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1405| |
1406| 494| if ( b->yy_is_our_buffer )
------------------
| Branch (1406:9): [True: 494, False: 0]
------------------
1407| 494| {
1408| 494| int new_size = b->yy_buf_size * 2;
1409| |
1410| 494| if ( new_size <= 0 )
------------------
| Branch (1410:10): [True: 0, False: 494]
------------------
1411| 0| b->yy_buf_size += b->yy_buf_size / 8;
1412| 494| else
1413| 494| b->yy_buf_size *= 2;
1414| |
1415| 494| b->yy_ch_buf = (char *)
1416| | /* Include room in for 2 EOB chars. */
1417| 494| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 494|#define yyrealloc igraph_gml_yyrealloc
------------------
1418| 494| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1419| 494| }
1420| 0| else
1421| | /* Can't grow it, we don't own it. */
1422| 0| b->yy_ch_buf = NULL;
1423| |
1424| 494| if ( ! b->yy_ch_buf )
------------------
| Branch (1424:9): [True: 0, False: 494]
------------------
1425| 494| 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| 494| "fatal error - scanner input buffer overflow" );
1427| |
1428| 494| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1429| |
1430| 494| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 494|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1431| 494| number_to_move - 1;
1432| |
1433| 494| }
1434| |
1435| 32.4k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 925| 32.4k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1435:8): [True: 30.1k, False: 2.29k]
------------------
1436| 30.1k| num_to_read = YY_READ_BUF_SIZE;
------------------
| | 925| 30.1k|#define YY_READ_BUF_SIZE 8192
------------------
1437| |
1438| | /* Read in more data. */
1439| 32.4k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 942| 32.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 32.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (942:7): [True: 0, False: 32.4k]
| | ------------------
| | 943| 32.4k| { \
| | 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| 32.4k| else \
| | 956| 32.4k| { \
| | 957| 32.4k| errno=0; \
| | 958| 32.4k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 32.4k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.17k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (958:11): [True: 3.17k, False: 29.2k]
| | | Branch (958:78): [True: 0, False: 3.17k]
| | ------------------
| | 959| 32.4k| { \
| | 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| 32.4k| }\
------------------
1440| 32.4k| yyg->yy_n_chars, num_to_read );
1441| |
1442| 32.4k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 32.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1443| 32.4k| }
1444| |
1445| 35.5k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1445:7): [True: 6.35k, False: 29.2k]
------------------
1446| 6.35k| {
1447| 6.35k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 712| 6.35k|#define YY_MORE_ADJ 0
------------------
| Branch (1447:8): [True: 3.17k, False: 3.17k]
------------------
1448| 3.17k| {
1449| 3.17k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.17k|#define EOB_ACT_END_OF_FILE 1
------------------
1450| 3.17k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.17k|#define yyrestart igraph_gml_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.17k|#define yyin yyg->yyin_r
------------------
1451| 3.17k| }
1452| |
1453| 3.17k| else
1454| 3.17k| {
1455| 3.17k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 3.17k|#define EOB_ACT_LAST_MATCH 2
------------------
1456| 3.17k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 3.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1457| 3.17k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 3.17k|#define YY_BUFFER_EOF_PENDING 2
------------------
1458| 3.17k| }
1459| 6.35k| }
1460| |
1461| 29.2k| else
1462| 29.2k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 29.2k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1463| |
1464| 35.5k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 35.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1464:6): [True: 0, False: 35.5k]
------------------
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.5k| yyg->yy_n_chars += number_to_move;
1476| 35.5k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 35.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| 35.5k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1477| 35.5k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 35.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| 35.5k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1478| |
1479| 35.5k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 35.5k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 35.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1480| |
1481| 35.5k| return ret_val;
1482| 35.5k|}
gml-lexer.c:yy_get_previous_state:
1487| 32.4k|{
1488| 32.4k| yy_state_type yy_current_state;
1489| 32.4k| char *yy_cp;
1490| 32.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1491| |
1492| 32.4k| yy_current_state = yyg->yy_start;
1493| 32.4k| yy_current_state += YY_AT_BOL();
------------------
| | 569| 32.4k|#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
| | ------------------
| | | | 527| 32.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1494| |
1495| 2.09G| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 579| 32.4k|#define yytext_ptr yytext_r
------------------
for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 712| 32.4k|#define YY_MORE_ADJ 0
------------------
| Branch (1495:47): [True: 2.09G, False: 32.4k]
------------------
1496| 2.09G| {
1497| 2.09G| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 23);
------------------
| | 346| 2.09G|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1497:19): [True: 2.09G, False: 0]
------------------
1498| 2.09G| if ( yy_accept[yy_current_state] )
------------------
| Branch (1498:8): [True: 192M, False: 1.89G]
------------------
1499| 192M| {
1500| 192M| yyg->yy_last_accepting_state = yy_current_state;
1501| 192M| yyg->yy_last_accepting_cpos = yy_cp;
1502| 192M| }
1503| 4.18G| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1503:11): [True: 2.09G, False: 2.09G]
------------------
1504| 2.09G| {
1505| 2.09G| yy_current_state = (int) yy_def[yy_current_state];
1506| 2.09G| if ( yy_current_state >= 43 )
------------------
| Branch (1506:9): [True: 2.09G, False: 22.1k]
------------------
1507| 2.09G| yy_c = yy_meta[yy_c];
1508| 2.09G| }
1509| 2.09G| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1510| 2.09G| }
1511| |
1512| 32.4k| return yy_current_state;
1513| 32.4k|}
gml-lexer.c:igraph_gml_yy_load_buffer_state:
1688| 9.53k|{
1689| 9.53k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1690| 9.53k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 9.53k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1691| 9.53k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 9.53k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 9.53k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1692| 9.53k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 9.53k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 9.53k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1693| 9.53k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1694| 9.53k|}
gml-lexer.c:igraph_gml_yy_init_buffer:
1752| 6.35k|{
1753| 6.35k| int oerrno = errno;
1754| 6.35k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1755| |
1756| 6.35k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 6.35k|#define yy_flush_buffer igraph_gml_yy_flush_buffer
------------------
1757| |
1758| 6.35k| b->yy_input_file = file;
1759| 6.35k| 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.35k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 6.35k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.35k, False: 0]
| | ------------------
| | 522| 6.35k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.35k| : NULL)
------------------
| Branch (1765:9): [True: 3.17k, False: 3.17k]
------------------
1766| 3.17k| b->yy_bs_lineno = 1;
1767| 3.17k| b->yy_bs_column = 0;
1768| 3.17k| }
1769| |
1770| 6.35k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1770:32): [True: 6.35k, False: 0]
------------------
1771| |
1772| | errno = oerrno;
1773| 6.35k|}
gml-lexer.c:igraph_gml_yyensure_buffer_stack:
1861| 3.17k|{
1862| 3.17k| yy_size_t num_to_alloc;
1863| 3.17k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1864| |
1865| 3.17k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1865:6): [True: 3.17k, 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.17k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1872| 3.17k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.17k|#define yyalloc igraph_gml_yyalloc
------------------
1873| 3.17k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1874| 3.17k| , yyscanner);
1875| 3.17k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1875:8): [True: 0, False: 3.17k]
------------------
1876| 3.17k| 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.17k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1879| |
1880| 3.17k| yyg->yy_buffer_stack_max = num_to_alloc;
1881| 3.17k| yyg->yy_buffer_stack_top = 0;
1882| 3.17k| return;
1883| 3.17k| }
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.35k|{
2251| 6.35k| 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.35k| yyg->yy_buffer_stack = NULL;
2257| 6.35k| yyg->yy_buffer_stack_top = 0;
2258| 6.35k| yyg->yy_buffer_stack_max = 0;
2259| 6.35k| yyg->yy_c_buf_p = NULL;
2260| 6.35k| yyg->yy_init = 0;
2261| 6.35k| yyg->yy_start = 0;
2262| |
2263| 6.35k| yyg->yy_start_stack_ptr = 0;
2264| 6.35k| yyg->yy_start_stack_depth = 0;
2265| 6.35k| 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.35k| yyin = NULL;
------------------
| | 356| 6.35k|#define yyin yyg->yyin_r
------------------
2273| 6.35k| yyout = NULL;
------------------
| | 357| 6.35k|#define yyout yyg->yyout_r
------------------
2274| 6.35k|#endif
2275| |
2276| | /* For future reference: Set errno on error, since we are called by
2277| | * yylex_init()
2278| | */
2279| 6.35k| return 0;
2280| 6.35k|}
igraph_gml_yyparse:
1239| 3.17k|{
1240| |/* The lookahead symbol. */
1241| 3.17k|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.17k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 380| 3.17k|# define YY_INITIAL_VALUE(Value) Value
------------------
1248| 3.17k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 380| 3.17k|# define YY_INITIAL_VALUE(Value) Value
------------------
1249| |
1250| |/* Location data for the lookahead symbol. */
1251| 3.17k|static YYLTYPE yyloc_default
1252| 3.17k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1253| 3.17k| = { 1, 1, 1, 1 }
1254| 3.17k|# endif
1255| 3.17k|;
1256| 3.17k|YYLTYPE yylloc = yyloc_default;
1257| |
1258| | /* Number of syntax errors so far. */
1259| 3.17k| int yynerrs;
1260| |
1261| 3.17k| yy_state_fast_t yystate;
1262| | /* Number of tokens to shift before error messages enabled. */
1263| 3.17k| 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.17k| yy_state_t yyssa[YYINITDEPTH];
1275| 3.17k| yy_state_t *yyss;
1276| 3.17k| yy_state_t *yyssp;
1277| |
1278| | /* The semantic value stack. */
1279| 3.17k| YYSTYPE yyvsa[YYINITDEPTH];
1280| 3.17k| YYSTYPE *yyvs;
1281| 3.17k| YYSTYPE *yyvsp;
1282| |
1283| | /* The location stack. */
1284| 3.17k| YYLTYPE yylsa[YYINITDEPTH];
1285| 3.17k| YYLTYPE *yyls;
1286| 3.17k| YYLTYPE *yylsp;
1287| |
1288| | /* The locations where the error started and ended. */
1289| 3.17k| YYLTYPE yyerror_range[3];
1290| |
1291| 3.17k| YYPTRDIFF_T yystacksize;
------------------
| | 295| 3.17k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1292| |
1293| 3.17k| int yyn;
1294| 3.17k| int yyresult;
1295| | /* Lookahead token as an internal (translated) token number. */
1296| 3.17k| int yytoken = 0;
1297| | /* The variables used to return semantic value and location from the
1298| | action routines. */
1299| 3.17k| YYSTYPE yyval;
1300| 3.17k| YYLTYPE yyloc;
1301| |
1302| 3.17k|#if YYERROR_VERBOSE
1303| | /* Buffer for error messages, and its allocated size. */
1304| 3.17k| char yymsgbuf[128];
1305| 3.17k| char *yymsg = yymsgbuf;
1306| 3.17k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 295| 3.17k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1307| 3.17k|#endif
1308| |
1309| 3.17k|#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.17k| int yylen = 0;
1314| |
1315| 3.17k| yyssp = yyss = yyssa;
1316| 3.17k| yyvsp = yyvs = yyvsa;
1317| 3.17k| yylsp = yyls = yylsa;
1318| 3.17k| yystacksize = YYINITDEPTH;
------------------
| | 936| 3.17k|# define YYINITDEPTH 200
------------------
1319| |
1320| 3.17k| YYDPRINTF ((stderr, "Starting parse\n"));
1321| |
1322| 3.17k| yystate = 0;
1323| 3.17k| yyerrstatus = 0;
1324| 3.17k| yynerrs = 0;
------------------
| | 71| 3.17k|#define yynerrs igraph_gml_yynerrs
------------------
1325| 3.17k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 700| 3.17k|#define YYEMPTY (-2)
------------------
1326| 3.17k| yylsp[0] = yylloc;
1327| 3.17k| goto yysetstate;
1328| |
1329| |
1330| |/*------------------------------------------------------------.
1331| || yynewstate -- push a new state, which is found in yystate. |
1332| |`------------------------------------------------------------*/
1333| 9.05M|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| 9.05M| yyssp++;
1337| |
1338| |
1339| |/*--------------------------------------------------------------------.
1340| || yysetstate -- set current state (the top of the stack) to yystate. |
1341| |`--------------------------------------------------------------------*/
1342| 9.06M|yysetstate:
1343| 9.06M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1344| 9.06M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 403| 9.06M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (403:31): [Folded, False: 9.06M]
| | | Branch (403:37): [True: 0, False: 0]
| | | Branch (403:37): [True: 0, False: 0]
| | ------------------
------------------
1345| 9.06M| YY_IGNORE_USELESS_CAST_BEGIN
1346| 9.06M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 143| 9.06M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1347| 9.06M| YY_IGNORE_USELESS_CAST_END
1348| |
1349| 9.06M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1349:7): [True: 0, False: 9.06M]
------------------
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| 9.06M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1416| |
1417| 9.06M| if (yystate == YYFINAL)
------------------
| | 537| 9.06M|#define YYFINAL 6
------------------
| Branch (1417:7): [True: 3.17k, False: 9.05M]
------------------
1418| 3.17k| YYACCEPT;
------------------
| | 703| 3.17k|#define YYACCEPT goto yyacceptlab
------------------
1419| |
1420| 9.05M| goto yybackup;
1421| |
1422| |
1423| |/*-----------.
1424| || yybackup. |
1425| |`-----------*/
1426| 9.05M|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| 9.05M| yyn = yypact[yystate];
1432| 9.05M| if (yypact_value_is_default (yyn))
------------------
| | 624| 9.05M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 621| 9.05M|#define YYPACT_NINF (-4)
| | ------------------
| | | Branch (624:3): [True: 5.64M, False: 3.41M]
| | ------------------
------------------
1433| 5.64M| 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.41M| if (yychar == YYEMPTY)
------------------
| | 700| 3.41M|#define YYEMPTY (-2)
------------------
| Branch (1438:7): [True: 3.40M, False: 3.17k]
------------------
1439| 3.40M| {
1440| 3.40M| YYDPRINTF ((stderr, "Reading a token: "));
1441| 3.40M| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 3.40M|#define yylex igraph_gml_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 133| 3.40M|#define scanner context->scanner
------------------
1442| 3.40M| }
1443| |
1444| 3.41M| if (yychar <= YYEOF)
------------------
| | 701| 3.41M|#define YYEOF 0
------------------
| Branch (1444:7): [True: 6.35k, False: 3.40M]
------------------
1445| 6.35k| {
1446| 6.35k| yychar = yytoken = YYEOF;
------------------
| | 701| 6.35k|#define YYEOF 0
------------------
1447| 6.35k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1448| 6.35k| }
1449| 3.40M| else
1450| 3.40M| {
1451| 3.40M| yytoken = YYTRANSLATE (yychar);
------------------
| | 557| 3.40M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 551| 3.40M|#define YYMAXUTOK 263
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 550| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (557:4): [True: 3.40M, False: 0]
| | | Branch (557:18): [True: 3.40M, False: 0]
| | ------------------
------------------
1452| 3.40M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1453| 3.40M| }
1454| |
1455| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1456| | detect an error, take that action. */
1457| 3.41M| yyn += yytoken;
1458| 3.41M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 539| 3.41M|#define YYLAST 10
------------------
| Branch (1458:7): [True: 0, False: 3.41M]
| Branch (1458:18): [True: 0, False: 3.41M]
| Branch (1458:34): [True: 3.17k, False: 3.40M]
------------------
1459| 3.17k| goto yydefault;
1460| 3.40M| yyn = yytable[yyn];
1461| 3.40M| if (yyn <= 0)
------------------
| Branch (1461:7): [True: 0, False: 3.40M]
------------------
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.40M| if (yyerrstatus)
------------------
| Branch (1471:7): [True: 0, False: 3.40M]
------------------
1472| 0| yyerrstatus--;
1473| |
1474| | /* Shift the lookahead token. */
1475| 3.40M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1476| 3.40M| yystate = yyn;
1477| 3.40M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1478| 3.40M| *++yyvsp = yylval;
1479| 3.40M| YY_IGNORE_MAYBE_UNINITIALIZED_END
1480| 3.40M| *++yylsp = yylloc;
1481| |
1482| | /* Discard the shifted token. */
1483| 3.40M| yychar = YYEMPTY;
------------------
| | 700| 3.40M|#define YYEMPTY (-2)
------------------
1484| 3.40M| goto yynewstate;
1485| |
1486| |
1487| |/*-----------------------------------------------------------.
1488| || yydefault -- do the default action for the current state. |
1489| |`-----------------------------------------------------------*/
1490| 5.64M|yydefault:
1491| 5.64M| yyn = yydefact[yystate];
1492| 5.64M| if (yyn == 0)
------------------
| Branch (1492:7): [True: 0, False: 5.64M]
------------------
1493| 0| goto yyerrlab;
1494| 5.64M| goto yyreduce;
1495| |
1496| |
1497| |/*-----------------------------.
1498| || yyreduce -- do a reduction. |
1499| |`-----------------------------*/
1500| 5.64M|yyreduce:
1501| | /* yyn is the number of a rule to reduce with. */
1502| 5.64M| 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.64M| yyval = yyvsp[1-yylen];
1513| |
1514| | /* Default location. */
1515| 5.64M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 738| 5.64M| do \
| | 739| 5.64M| if (N) \
| | ------------------
| | | Branch (739:11): [True: 5.64M, False: 0]
| | ------------------
| | 740| 5.64M| { \
| | 741| 5.64M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 756| 5.64M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 742| 5.64M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 756| 5.64M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 743| 5.64M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 756| 5.64M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 744| 5.64M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 756| 5.64M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 745| 5.64M| } \
| | 746| 5.64M| else \
| | 747| 5.64M| { \
| | 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.64M| while (0)
| | ------------------
| | | Branch (753:12): [Folded, False: 5.64M]
| | ------------------
------------------
1516| 5.64M| yyerror_range[1] = yyloc;
1517| 5.64M| YY_REDUCE_PRINT (yyn);
1518| 5.64M| switch (yyn)
1519| 5.64M| {
1520| 3.17k| case 2:
------------------
| Branch (1520:3): [True: 3.17k, False: 5.64M]
------------------
1521| 3.17k|#line 122 "/src/igraph/src/io/gml-parser.y"
1522| 3.17k| { context->tree=(yyvsp[0].tree); }
1523| 3.17k|#line 1524 "/src/igraph/build/src/io/parsers/gml-parser.c"
1524| 3.17k| break;
1525| |
1526| 0| case 3:
------------------
| Branch (1526:3): [True: 0, False: 5.64M]
------------------
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| 391k| case 4:
------------------
| Branch (1532:3): [True: 391k, False: 5.25M]
------------------
1533| 391k|#line 125 "/src/igraph/src/io/gml-parser.y"
1534| 391k| { (yyval.tree)=(yyvsp[0].tree); }
1535| 391k|#line 1536 "/src/igraph/build/src/io/parsers/gml-parser.c"
1536| 391k| break;
1537| |
1538| 1.11M| case 5:
------------------
| Branch (1538:3): [True: 1.11M, False: 4.53M]
------------------
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| 757k| case 6:
------------------
| Branch (1544:3): [True: 757k, False: 4.89M]
------------------
1545| 757k|#line 129 "/src/igraph/src/io/gml-parser.y"
1546| 757k| { IGRAPH_YY_CHECK(igraph_i_gml_make_numeric((yyvsp[-1].str), (yylsp[-1]).first_line, (yyvsp[0].real), &(yyval.tree))); }
------------------
| | 10| 757k| do { \
| | 11| 757k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 757k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 757k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 757k]
| | | | ------------------
| | ------------------
| | 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| 757k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 757k]
| | ------------------
------------------
1547| 757k|#line 1548 "/src/igraph/build/src/io/parsers/gml-parser.c"
1548| 757k| break;
1549| |
1550| 757k| case 7:
------------------
| Branch (1550:3): [True: 362k, False: 5.28M]
------------------
1551| 362k|#line 131 "/src/igraph/src/io/gml-parser.y"
1552| 362k| { IGRAPH_YY_CHECK(igraph_i_gml_make_string((yyvsp[-1].str), (yylsp[-1]).first_line, (yyvsp[0].str), &(yyval.tree))); }
------------------
| | 10| 362k| do { \
| | 11| 362k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 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]
| | | | ------------------
| | ------------------
| | 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| 362k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 362k]
| | ------------------
------------------
1553| 362k|#line 1554 "/src/igraph/build/src/io/parsers/gml-parser.c"
1554| 362k| break;
1555| |
1556| 388k| case 8:
------------------
| Branch (1556:3): [True: 388k, False: 5.26M]
------------------
1557| 388k|#line 133 "/src/igraph/src/io/gml-parser.y"
1558| 388k| { IGRAPH_YY_CHECK(igraph_i_gml_make_list((yyvsp[-3].str), (yylsp[-3]).first_line, (yyvsp[-1].tree), &(yyval.tree))); }
------------------
| | 10| 388k| do { \
| | 11| 388k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 388k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 388k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 388k]
| | | | ------------------
| | ------------------
| | 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| 388k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 388k]
| | ------------------
------------------
1559| 388k|#line 1560 "/src/igraph/build/src/io/parsers/gml-parser.c"
1560| 388k| break;
1561| |
1562| 1.50M| case 9:
------------------
| Branch (1562:3): [True: 1.50M, False: 4.14M]
------------------
1563| 1.50M|#line 136 "/src/igraph/src/io/gml-parser.y"
1564| 1.50M| { IGRAPH_YY_CHECK(igraph_i_gml_get_keyword(igraph_gml_yyget_text(scanner),
------------------
| | 10| 1.50M| do { \
| | 11| 1.50M| igraph_error_t igraph_i_ret = (expr); \
| | 12| 1.50M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 1.50M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.50M]
| | | | ------------------
| | ------------------
| | 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.50M| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 1.50M]
| | ------------------
------------------
1565| 1.50M| igraph_gml_yyget_leng(scanner),
1566| 1.50M| &(yyval.str))); }
1567| 1.50M|#line 1568 "/src/igraph/build/src/io/parsers/gml-parser.c"
1568| 1.50M| break;
1569| |
1570| 1.50M| case 10:
------------------
| Branch (1570:3): [True: 757k, False: 4.89M]
------------------
1571| 757k|#line 139 "/src/igraph/src/io/gml-parser.y"
1572| 757k| {
1573| 757k| igraph_real_t val;
1574| 757k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_gml_yyget_text(scanner),
------------------
| | 10| 757k| do { \
| | 11| 757k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 757k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 757k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 757k]
| | | | ------------------
| | ------------------
| | 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| 757k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 757k]
| | ------------------
------------------
1575| 757k| igraph_gml_yyget_leng(scanner),
1576| 757k| &val));
1577| 757k| (yyval.real)=val;
1578| 757k|}
1579| 0|#line 1580 "/src/igraph/build/src/io/parsers/gml-parser.c"
1580| 0| break;
1581| |
1582| 362k| case 11:
------------------
| Branch (1582:3): [True: 362k, False: 5.28M]
------------------
1583| 362k|#line 147 "/src/igraph/src/io/gml-parser.y"
1584| 362k| { IGRAPH_YY_CHECK(igraph_i_gml_get_string(igraph_gml_yyget_text(scanner),
------------------
| | 10| 362k| do { \
| | 11| 362k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 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]
| | | | ------------------
| | ------------------
| | 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| 362k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 362k]
| | ------------------
------------------
1585| 362k| igraph_gml_yyget_leng(scanner),
1586| 362k| &(yyval.str))); }
1587| 362k|#line 1588 "/src/igraph/build/src/io/parsers/gml-parser.c"
1588| 362k| break;
1589| |
1590| |
1591| 362k|#line 1592 "/src/igraph/build/src/io/parsers/gml-parser.c"
1592| |
1593| 362k| default: break;
------------------
| Branch (1593:7): [True: 0, False: 5.64M]
------------------
1594| 5.64M| }
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.64M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1607| |
1608| 5.64M| YYPOPSTACK (yylen);
------------------
| | 1309| 5.64M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1609| 5.64M| yylen = 0;
1610| 5.64M| YY_STACK_PRINT (yyss, yyssp);
1611| |
1612| 5.64M| *++yyvsp = yyval;
1613| 5.64M| *++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.64M| {
1619| 5.64M| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 542| 5.64M|#define YYNTOKENS 9
------------------
1620| 5.64M| const int yyi = yypgoto[yylhs] + *yyssp;
1621| 5.64M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 539| 11.2M|#define YYLAST 10
------------------
| Branch (1621:16): [True: 5.62M, False: 25.4k]
| Branch (1621:28): [True: 5.62M, False: 0]
| Branch (1621:45): [True: 2.61M, False: 3.00M]
------------------
1622| 5.64M| ? yytable[yyi]
1623| 5.64M| : yydefgoto[yylhs]);
1624| 5.64M| }
1625| |
1626| 5.64M| 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.17k|yyacceptlab:
1774| 3.17k| yyresult = 0;
1775| 3.17k| 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.17k|yyreturn:
1801| 3.17k| if (yychar != YYEMPTY)
------------------
| | 700| 3.17k|#define YYEMPTY (-2)
------------------
| Branch (1801:7): [True: 0, False: 3.17k]
------------------
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.17k| YYPOPSTACK (yylen);
------------------
| | 1309| 3.17k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1812| 3.17k| YY_STACK_PRINT (yyss, yyssp);
1813| 9.53k| while (yyssp != yyss)
------------------
| Branch (1813:10): [True: 6.35k, False: 3.17k]
------------------
1814| 6.35k| {
1815| 6.35k| yydestruct ("Cleanup: popping",
1816| 6.35k| yystos[+*yyssp], yyvsp, yylsp, context);
1817| 6.35k| YYPOPSTACK (1);
------------------
| | 1309| 6.35k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1818| 6.35k| }
1819| 3.17k|#ifndef yyoverflow
1820| 3.17k| if (yyss != yyssa)
------------------
| Branch (1820:7): [True: 0, False: 3.17k]
------------------
1821| 0| YYSTACK_FREE (yyss);
------------------
| | 445| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 464| 0|# define YYFREE free
| | ------------------
------------------
1822| 3.17k|#endif
1823| 3.17k|#if YYERROR_VERBOSE
1824| 3.17k| if (yymsg != yymsgbuf)
------------------
| Branch (1824:7): [True: 0, False: 3.17k]
------------------
1825| 0| YYSTACK_FREE (yymsg);
------------------
| | 445| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 464| 0|# define YYFREE free
| | ------------------
------------------
1826| 3.17k|#endif
1827| 3.17k| return yyresult;
1828| 0|}
gml-parser.c:yydestruct:
1189| 6.35k|{
1190| 6.35k| YYUSE (yyvaluep);
------------------
| | 366| 6.35k|# define YYUSE(E) ((void) (E))
------------------
1191| 6.35k| YYUSE (yylocationp);
------------------
| | 366| 6.35k|# define YYUSE(E) ((void) (E))
------------------
1192| 6.35k| YYUSE (context);
------------------
| | 366| 6.35k|# define YYUSE(E) ((void) (E))
------------------
1193| 6.35k| if (!yymsg)
------------------
| Branch (1193:7): [True: 0, False: 6.35k]
------------------
1194| 0| yymsg = "Deleting";
1195| 6.35k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1196| |
1197| 6.35k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1198| 6.35k| switch (yytype)
1199| 6.35k| {
1200| 0| case 11: /* list */
------------------
| Branch (1200:5): [True: 0, False: 6.35k]
------------------
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.35k]
------------------
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.35k]
------------------
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.35k]
------------------
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.35k| default:
------------------
| Branch (1224:7): [True: 6.35k, False: 0]
------------------
1225| 6.35k| break;
1226| 6.35k| }
1227| 6.35k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1228| 6.35k|}
gml-parser.c:igraph_i_gml_get_keyword:
1840| 1.50M|static igraph_error_t igraph_i_gml_get_keyword(const char *s, size_t len, char **res) {
1841| 1.50M| *res = strndup(s, len);
1842| 1.50M| if (! *res) {
------------------
| Branch (1842:7): [True: 0, False: 1.50M]
------------------
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.50M| return IGRAPH_SUCCESS;
1846| 1.50M|}
gml-parser.c:igraph_i_gml_get_string:
1848| 362k|static igraph_error_t igraph_i_gml_get_string(const char *s, size_t len, char **res) {
1849| 362k| *res = strndup(s+1, len-2);
1850| 362k| if (! *res) {
------------------
| Branch (1850:7): [True: 0, False: 362k]
------------------
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| 362k| return IGRAPH_SUCCESS;
1854| 362k|}
gml-parser.c:igraph_i_gml_make_numeric:
1859| 757k| igraph_gml_tree_t **tree) {
1860| |
1861| 757k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 757k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.51M| (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: 757k, Folded]
| | | | ------------------
| | ------------------
------------------
1862| 757k| if (!t) {
------------------
| Branch (1862:7): [True: 0, False: 757k]
------------------
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| 757k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 757k| do { \
| | 604| 757k| /* the following branch makes the compiler check the compatibility of \
| | 605| 757k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 757k| * incorrect destructor function with the pointer */ \
| | 607| 757k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 757k]
| | ------------------
| | 608| 757k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 757k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 757k]
| | ------------------
------------------
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| 757k| igraph_real_t trunc_value = trunc(value);
1874| 757k| if (value == trunc_value && igraph_i_is_real_representable_as_integer(trunc_value)) {
------------------
| Branch (1874:7): [True: 756k, False: 685]
| Branch (1874:31): [True: 756k, False: 221]
------------------
1875| 756k| IGRAPH_CHECK(igraph_gml_tree_init_integer(t, name, line, value));
------------------
| | 656| 756k| do { \
| | 657| 756k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 756k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 756k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 756k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 756k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 756k]
| | ------------------
------------------
1876| 756k| } else {
1877| 906| IGRAPH_CHECK(igraph_gml_tree_init_real(t, name, line, value));
------------------
| | 656| 906| do { \
| | 657| 906| igraph_error_t igraph_i_ret = (expr); \
| | 658| 906| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 906| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 906]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 906| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 906]
| | ------------------
------------------
1878| 906| }
1879| |
1880| 757k| *tree = t;
1881| 757k| IGRAPH_FINALLY_CLEAN(1); /* t */
1882| |
1883| 757k| return IGRAPH_SUCCESS;
1884| 757k|}
gml-parser.c:igraph_i_gml_make_string:
1889| 362k| igraph_gml_tree_t **tree) {
1890| |
1891| 362k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 362k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 725k| (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: 362k, Folded]
| | | | ------------------
| | ------------------
------------------
1892| 362k| if (!t) {
------------------
| Branch (1892:7): [True: 0, False: 362k]
------------------
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| 362k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 362k| do { \
| | 604| 362k| /* the following branch makes the compiler check the compatibility of \
| | 605| 362k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 362k| * incorrect destructor function with the pointer */ \
| | 607| 362k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 362k]
| | ------------------
| | 608| 362k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 362k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 362k]
| | ------------------
------------------
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| 362k| IGRAPH_FINALLY(igraph_free, value);
------------------
| | 603| 362k| do { \
| | 604| 362k| /* the following branch makes the compiler check the compatibility of \
| | 605| 362k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 362k| * incorrect destructor function with the pointer */ \
| | 607| 362k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 362k]
| | ------------------
| | 608| 362k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 362k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 362k]
| | ------------------
------------------
1901| 362k| IGRAPH_CHECK(igraph_gml_tree_init_string(t, name, line, value));
------------------
| | 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]
| | ------------------
------------------
1902| |
1903| 362k| IGRAPH_FINALLY_CLEAN(1); /* value */
1904| |
1905| 362k| *tree = t;
1906| 362k| IGRAPH_FINALLY_CLEAN(1); /* t */
1907| |
1908| 362k| return IGRAPH_SUCCESS;
1909| 362k|}
gml-parser.c:igraph_i_gml_make_list:
1914| 388k| igraph_gml_tree_t **tree) {
1915| |
1916| 388k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 388k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 777k| (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: 388k, Folded]
| | | | ------------------
| | ------------------
------------------
1917| 388k| if (!t) {
------------------
| Branch (1917:7): [True: 0, False: 388k]
------------------
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| 388k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 388k| do { \
| | 604| 388k| /* the following branch makes the compiler check the compatibility of \
| | 605| 388k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 388k| * incorrect destructor function with the pointer */ \
| | 607| 388k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 388k]
| | ------------------
| | 608| 388k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 388k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 388k]
| | ------------------
------------------
1921| |
1922| 388k| IGRAPH_CHECK(igraph_gml_tree_init_tree(t, name, line, list));
------------------
| | 656| 388k| do { \
| | 657| 388k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 388k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 388k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 388k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 388k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 388k]
| | ------------------
------------------
1923| |
1924| 388k| *tree = t;
1925| 388k| IGRAPH_FINALLY_CLEAN(1); /* t */
1926| |
1927| 388k| return IGRAPH_SUCCESS;
1928| 388k|}
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| 830k|{
995| 830k| yy_state_type yy_current_state;
996| 830k| char *yy_cp, *yy_bp;
997| 830k| int yy_act;
998| 830k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
999| |
1000| 830k| yylval = yylval_param;
------------------
| | 807| 830k| # define yylval yyg->yylval_r
------------------
1001| |
1002| 830k| yylloc = yylloc_param;
------------------
| | 809| 830k| # define yylloc yyg->yylloc_r
------------------
1003| |
1004| 830k| if ( !yyg->yy_init )
------------------
| Branch (1004:7): [True: 3.02k, False: 827k]
------------------
1005| 3.02k| {
1006| 3.02k| yyg->yy_init = 1;
1007| |
1008| |#ifdef YY_USER_INIT
1009| | YY_USER_INIT;
1010| |#endif
1011| |
1012| 3.02k| if ( ! yyg->yy_start )
------------------
| Branch (1012:8): [True: 3.02k, False: 0]
------------------
1013| 3.02k| yyg->yy_start = 1; /* first start state */
1014| |
1015| 3.02k| if ( ! yyin )
------------------
| | 356| 3.02k|#define yyin yyg->yyin_r
------------------
| Branch (1015:8): [True: 0, False: 3.02k]
------------------
1016| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1017| |
1018| 3.02k| if ( ! yyout )
------------------
| | 357| 3.02k|#define yyout yyg->yyout_r
------------------
| Branch (1018:8): [True: 3.02k, False: 0]
------------------
1019| 3.02k| yyout = stdout;
------------------
| | 357| 3.02k|#define yyout yyg->yyout_r
------------------
1020| |
1021| 3.02k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.02k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.02k]
| | ------------------
| | 522| 3.02k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.02k| : NULL)
------------------
| Branch (1021:8): [True: 3.02k, False: 0]
------------------
1022| 3.02k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.02k|#define yyensure_buffer_stack igraph_lgl_yyensure_buffer_stack
------------------
1023| 3.02k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.02k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1024| 3.02k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.02k|#define yy_create_buffer igraph_lgl_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.02k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.02k|#define YY_BUF_SIZE 16384
------------------
1025| 3.02k| }
1026| |
1027| 3.02k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.02k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1028| 3.02k| }
1029| |
1030| 830k| {
1031| 830k|#line 79 "/src/igraph/src/io/lgl-lexer.l"
1032| |
1033| |
1034| 830k|#line 82 "/src/igraph/src/io/lgl-lexer.l"
1035| | /* ------------------------------------------------whitespace------*/
1036| 830k|#line 1037 "/src/igraph/build/src/io/parsers/lgl-lexer.c"
1037| |
1038| 934k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1038:23): [True: 934k, Folded]
------------------
1039| 934k| {
1040| 934k| yy_cp = yyg->yy_c_buf_p;
1041| |
1042| | /* Support of yytext. */
1043| 934k| *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| 934k| yy_bp = yy_cp;
1049| |
1050| 934k| yy_current_state = yyg->yy_start;
1051| 942k|yy_match:
1052| 942k| do
1053| 48.6M| {
1054| 48.6M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 48.6M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1055| 48.6M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1055:9): [True: 47.7M, False: 936k]
------------------
1056| 47.7M| {
1057| 47.7M| yyg->yy_last_accepting_state = yy_current_state;
1058| 47.7M| yyg->yy_last_accepting_cpos = yy_cp;
1059| 47.7M| }
1060| 97.9M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1060:12): [True: 49.2M, False: 48.6M]
------------------
1061| 49.2M| {
1062| 49.2M| yy_current_state = (int) yy_def[yy_current_state];
1063| 49.2M| if ( yy_current_state >= 16 )
------------------
| Branch (1063:10): [True: 47.7M, False: 1.49M]
------------------
1064| 47.7M| yy_c = yy_meta[yy_c];
1065| 49.2M| }
1066| 48.6M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1067| 48.6M| ++yy_cp;
1068| 48.6M| }
1069| 48.6M| while ( yy_base[yy_current_state] != 12 );
------------------
| Branch (1069:11): [True: 47.7M, False: 942k]
------------------
1070| |
1071| 944k|yy_find_action:
1072| 944k| yy_act = yy_accept[yy_current_state];
1073| 944k| if ( yy_act == 0 )
------------------
| Branch (1073:8): [True: 929k, False: 14.8k]
------------------
1074| 929k| { /* have to back up */
1075| 929k| yy_cp = yyg->yy_last_accepting_cpos;
1076| 929k| yy_current_state = yyg->yy_last_accepting_state;
1077| 929k| yy_act = yy_accept[yy_current_state];
1078| 929k| }
1079| |
1080| 944k| YY_DO_BEFORE_ACTION;
------------------
| | 590| 944k| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 944k|#define yytext_ptr yytext_r
| | ------------------
| | 591| 944k| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 944k|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 944k| yyg->yy_hold_char = *yy_cp; \
| | 593| 944k| *yy_cp = '\0'; \
| | 594| 944k| yyg->yy_c_buf_p = yy_cp;
------------------
1081| |
1082| 944k| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 1.88M|#define YY_END_OF_BUFFER 7
------------------
| Branch (1082:8): [True: 931k, False: 13.3k]
| Branch (1082:38): [True: 362k, False: 569k]
------------------
1083| 362k| {
1084| 362k| int yyl;
1085| 724k| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 724k|#define yyleng yyg->yyleng_r
------------------
| Branch (1085:19): [True: 362k, False: 362k]
------------------
1086| 362k| if ( yytext[yyl] == '\n' )
------------------
| | 360| 362k|#define yytext yyg->yytext_r
------------------
| Branch (1086:10): [True: 362k, False: 0]
------------------
1087| |
1088| 362k| do{ yylineno++;
------------------
| | 361| 362k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 362k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1089| 362k| yycolumn=0;
------------------
| | 362| 362k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 362k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1090| 362k| }while(0)
------------------
| Branch (1090:12): [Folded, False: 362k]
------------------
1091| 362k|;
1092| 362k| }
1093| |
1094| 947k|do_action: /* This label is used only to access EOF actions. */
1095| |
1096| 947k| switch ( yy_act )
1097| 947k| { /* beginning of action switch */
1098| 0| case 0: /* must back up */
------------------
| Branch (1098:4): [True: 0, False: 947k]
------------------
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| 103k|case 1:
------------------
| Branch (1105:1): [True: 103k, False: 844k]
------------------
1106| 103k|YY_RULE_SETUP
------------------
| | 989| 103k| YY_USER_ACTION
| | ------------------
| | | | 735| 103k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 103k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 103k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 103k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1107| 103k|#line 83 "/src/igraph/src/io/lgl-lexer.l"
1108| 103k|{ /* skip space */ }
1109| 103k| YY_BREAK
------------------
| | 985| 103k|#define YY_BREAK /*LINTED*/break;
------------------
1110| |/* --------------------------------------------------hashmark------*/
1111| 12.6k|case 2:
------------------
| Branch (1111:1): [True: 12.6k, False: 934k]
------------------
1112| 12.6k|YY_RULE_SETUP
------------------
| | 989| 12.6k| YY_USER_ACTION
| | ------------------
| | | | 735| 12.6k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 12.6k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 12.6k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 12.6k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1113| 12.6k|#line 86 "/src/igraph/src/io/lgl-lexer.l"
1114| 12.6k|{ BEGIN(LINE); return HASH; }
------------------
| | 369| 12.6k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return HASH; }
------------------
| | 751| 12.6k|#define LINE 1
------------------
1115| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1116| |/* ----------------------------------------------alphanumeric------*/
1117| 452k|case 3:
------------------
| Branch (1117:1): [True: 452k, False: 494k]
------------------
1118| 452k|YY_RULE_SETUP
------------------
| | 989| 452k| YY_USER_ACTION
| | ------------------
| | | | 735| 452k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 452k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 452k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 452k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1119| 452k|#line 89 "/src/igraph/src/io/lgl-lexer.l"
1120| 452k|{ BEGIN(LINE); return ALNUM; }
------------------
| | 369| 452k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return ALNUM; }
------------------
| | 751| 452k|#define LINE 1
------------------
1121| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1122| |/* ---------------------------------------------------newline------*/
1123| 362k|case 4:
------------------
| Branch (1123:1): [True: 362k, False: 585k]
------------------
1124| |/* rule 4 can match eol */
1125| 362k|#line 93 "/src/igraph/src/io/lgl-lexer.l"
1126| 362k|YY_RULE_SETUP
------------------
| | 989| 362k| YY_USER_ACTION
| | ------------------
| | | | 735| 362k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 362k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 362k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 362k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1127| 362k|case YY_STATE_EOF(LINE):
------------------
| | 377| 362k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 362k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
| Branch (1127:1): [True: 0, False: 947k]
------------------
1128| 362k|#line 93 "/src/igraph/src/io/lgl-lexer.l"
1129| 362k|{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 369| 362k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 750| 362k|#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: 947k]
------------------
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: 947k]
------------------
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.02k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.02k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.02k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
| Branch (1143:1): [True: 3.02k, False: 944k]
------------------
1144| 3.02k| yyterminate();
------------------
| | 948| 3.02k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.02k|#define YY_NULL 0
| | ------------------
------------------
1145| |
1146| 13.3k| case YY_END_OF_BUFFER:
------------------
| | 596| 13.3k|#define YY_END_OF_BUFFER 7
------------------
| Branch (1146:2): [True: 13.3k, False: 934k]
------------------
1147| 13.3k| {
1148| | /* Amount of text matched not including the EOB char. */
1149| 13.3k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 13.3k|#define yytext_ptr yytext_r
------------------
1150| |
1151| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1152| 13.3k| *yy_cp = yyg->yy_hold_char;
1153| 13.3k| YY_RESTORE_YY_MORE_OFFSET
1154| |
1155| 13.3k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 13.3k|#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.3k|#define YY_BUFFER_NEW 0
------------------
| Branch (1155:8): [True: 3.02k, False: 10.3k]
------------------
1156| 3.02k| {
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.02k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.02k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1167| 3.02k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.02k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.02k|#define yyin yyg->yyin_r
------------------
1168| 3.02k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.02k|#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.02k|#define YY_BUFFER_NORMAL 1
------------------
1169| 3.02k| }
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.3k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 13.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1178:8): [True: 0, False: 13.3k]
------------------
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.3k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1214:17): [True: 13.3k, False: 0]
------------------
1215| 13.3k| {
1216| 3.02k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.02k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1216:4): [True: 3.02k, False: 10.3k]
------------------
1217| 3.02k| {
1218| 3.02k| yyg->yy_did_buffer_switch_on_eof = 0;
1219| |
1220| 3.02k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.02k|#define yywrap igraph_lgl_yywrap
| | ------------------
| | | | 573| 3.02k|#define igraph_lgl_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:38): [True: 3.02k, Folded]
| | | | ------------------
| | ------------------
------------------
1221| 3.02k| {
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.02k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.02k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 3.02k|#define YY_MORE_ADJ 0
------------------
1232| |
1233| 3.02k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.02k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.02k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
1234| 3.02k| goto do_action;
1235| 3.02k| }
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.02k| }
1244| |
1245| 8.16k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 8.16k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1245:4): [True: 8.16k, False: 5.22k]
------------------
1246| 8.16k| yyg->yy_c_buf_p =
1247| 8.16k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 8.16k|#define yytext_ptr yytext_r
------------------
1248| |
1249| 8.16k| yy_current_state = yy_get_previous_state( yyscanner );
1250| |
1251| 8.16k| yy_cp = yyg->yy_c_buf_p;
1252| 8.16k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 8.16k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 8.16k|#define YY_MORE_ADJ 0
------------------
1253| 8.16k| goto yy_match;
1254| |
1255| 2.19k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 2.19k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1255:4): [True: 2.19k, False: 11.1k]
------------------
1256| 2.19k| yyg->yy_c_buf_p =
1257| 2.19k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 2.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1258| |
1259| 2.19k| yy_current_state = yy_get_previous_state( yyscanner );
1260| |
1261| 2.19k| yy_cp = yyg->yy_c_buf_p;
1262| 2.19k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 2.19k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 2.19k|#define YY_MORE_ADJ 0
------------------
1263| 2.19k| goto yy_find_action;
1264| 13.3k| }
1265| 0| break;
1266| 13.3k| }
1267| |
1268| 0| default:
------------------
| Branch (1268:2): [True: 0, False: 947k]
------------------
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| 947k| "fatal flex scanner internal error--no action found" );
1271| 947k| } /* end of action switch */
1272| 947k| } /* end of scanning one token */
1273| 830k| } /* end of user's declarations */
1274| 830k|} /* end of yylex */
igraph_lgl_yyrestart:
1572| 3.02k|{
1573| 3.02k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1574| |
1575| 3.02k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.02k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.02k, False: 0]
| | ------------------
| | 522| 3.02k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.02k| : NULL)
------------------
| Branch (1575:7): [True: 0, False: 3.02k]
------------------
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.02k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.02k|#define yy_init_buffer igraph_lgl_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.02k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.02k, False: 0]
| | ------------------
| | 522| 3.02k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.02k| : NULL)
------------------
1582| 3.02k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.02k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1583| 3.02k|}
igraph_lgl_yy_create_buffer:
1637| 3.02k|{
1638| 3.02k| YY_BUFFER_STATE b;
1639| |
1640| 3.02k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.02k|#define yyalloc igraph_lgl_yyalloc
------------------
1641| 3.02k| if ( ! b )
------------------
| Branch (1641:7): [True: 0, False: 3.02k]
------------------
1642| 3.02k| 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.02k| 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.02k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.02k|#define yyalloc igraph_lgl_yyalloc
------------------
1650| 3.02k| if ( ! b->yy_ch_buf )
------------------
| Branch (1650:7): [True: 0, False: 3.02k]
------------------
1651| 3.02k| 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.02k| b->yy_is_our_buffer = 1;
1654| |
1655| 3.02k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.02k|#define yy_init_buffer igraph_lgl_yy_init_buffer
------------------
1656| |
1657| 3.02k| return b;
1658| 3.02k|}
igraph_lgl_yy_delete_buffer:
1665| 3.02k|{
1666| 3.02k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1667| |
1668| 3.02k| if ( ! b )
------------------
| Branch (1668:7): [True: 0, False: 3.02k]
------------------
1669| 0| return;
1670| |
1671| 3.02k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.02k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.02k, False: 0]
| | ------------------
| | 522| 3.02k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.02k| : NULL)
------------------
| Branch (1671:7): [True: 3.02k, False: 0]
------------------
1672| 3.02k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.02k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1673| |
1674| 3.02k| if ( b->yy_is_our_buffer )
------------------
| Branch (1674:7): [True: 3.02k, False: 0]
------------------
1675| 3.02k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.02k|#define yyfree igraph_lgl_yyfree
------------------
1676| |
1677| 3.02k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.02k|#define yyfree igraph_lgl_yyfree
------------------
1678| 3.02k|}
igraph_lgl_yy_flush_buffer:
1714| 6.05k|{
1715| 6.05k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1716| 6.05k| if ( ! b )
------------------
| Branch (1716:7): [True: 0, False: 6.05k]
------------------
1717| 0| return;
1718| |
1719| 6.05k| 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.05k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.05k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1726| 6.05k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.05k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1727| |
1728| 6.05k| b->yy_buf_pos = &b->yy_ch_buf[0];
1729| |
1730| 6.05k| b->yy_at_bol = 1;
1731| 6.05k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 6.05k|#define YY_BUFFER_NEW 0
------------------
1732| |
1733| 6.05k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 6.05k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.05k, False: 0]
| | ------------------
| | 522| 6.05k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.05k| : NULL)
------------------
| Branch (1733:7): [True: 3.02k, False: 3.02k]
------------------
1734| 3.02k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.02k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1735| 6.05k|}
igraph_lgl_yypop_buffer_state:
1775| 3.02k|{
1776| 3.02k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1777| 3.02k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.02k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.02k, False: 0]
| | ------------------
| | 522| 3.02k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.02k| : NULL)
------------------
| Branch (1777:6): [True: 3.02k, False: 0]
------------------
1778| 3.02k| 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| 452k|{
2013| 452k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2014| 452k| return yyleng;
------------------
| | 359| 452k|#define yyleng yyg->yyleng_r
------------------
2015| 452k|}
igraph_lgl_yyget_text:
2022| 452k|{
2023| 452k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2024| 452k| return yytext;
------------------
| | 360| 452k|#define yytext yyg->yytext_r
------------------
2025| 452k|}
igraph_lgl_yyset_extra:
2032| 6.05k|{
2033| 6.05k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2034| 6.05k| yyextra = user_defined ;
------------------
| | 358| 6.05k|#define yyextra yyg->yyextra_r
------------------
2035| 6.05k|}
igraph_lgl_yyset_in:
2074| 3.02k|{
2075| 3.02k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2076| 3.02k| yyin = _in_str ;
------------------
| | 356| 3.02k|#define yyin yyg->yyin_r
------------------
2077| 3.02k|}
igraph_lgl_yylex_init_extra:
2157| 3.02k|{
2158| 3.02k| struct yyguts_t dummy_yyguts;
2159| |
2160| 3.02k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.02k|#define yyset_extra igraph_lgl_yyset_extra
------------------
2161| |
2162| 3.02k| if (ptr_yy_globals == NULL){
------------------
| Branch (2162:9): [True: 0, False: 3.02k]
------------------
2163| 0| errno = EINVAL;
2164| 0| return 1;
2165| 0| }
2166| |
2167| 3.02k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.02k|#define yyalloc igraph_lgl_yyalloc
------------------
2168| |
2169| 3.02k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2169:9): [True: 0, False: 3.02k]
------------------
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.02k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2177| |
2178| 3.02k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.02k|#define yyset_extra igraph_lgl_yyset_extra
------------------
2179| |
2180| 3.02k| return yy_init_globals ( *ptr_yy_globals );
2181| 3.02k|}
igraph_lgl_yylex_destroy:
2218| 3.02k|{
2219| 3.02k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2220| |
2221| | /* Pop the buffer stack, destroying each element. */
2222| 6.05k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 6.05k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.02k, False: 3.02k]
| | | Branch (521:29): [True: 6.05k, False: 0]
| | ------------------
| | 522| 6.05k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.05k| : NULL)
------------------
2223| 3.02k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.02k|#define yy_delete_buffer igraph_lgl_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.02k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.02k, False: 0]
| | ------------------
| | 522| 3.02k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.02k| : NULL)
------------------
2224| 3.02k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.02k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2225| 3.02k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.02k|#define yypop_buffer_state igraph_lgl_yypop_buffer_state
------------------
2226| 3.02k| }
2227| |
2228| | /* Destroy the stack itself. */
2229| 3.02k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.02k|#define yyfree igraph_lgl_yyfree
------------------
2230| 3.02k| yyg->yy_buffer_stack = NULL;
2231| |
2232| | /* Destroy the start condition stack. */
2233| 3.02k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.02k|#define yyfree igraph_lgl_yyfree
------------------
2234| 3.02k| 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.02k| yy_init_globals( yyscanner);
2239| |
2240| | /* Destroy the main struct (reentrant only). */
2241| 3.02k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.02k|#define yyfree igraph_lgl_yyfree
------------------
2242| | yyscanner = NULL;
2243| 3.02k| return 0;
2244| 3.02k|}
igraph_lgl_yyalloc:
2274| 12.1k|{
2275| 12.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2276| 12.1k| (void)yyg;
2277| 12.1k| return malloc(size);
2278| 12.1k|}
igraph_lgl_yyrealloc:
2281| 85|{
2282| 85| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2283| 85| (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| 85| return realloc(ptr, size);
2293| 85|}
igraph_lgl_yyfree:
2296| 15.1k|{
2297| 15.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2298| 15.1k| (void)yyg;
2299| 15.1k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2300| 15.1k|}
lgl-lexer.c:yy_get_next_buffer:
1284| 13.3k|{
1285| 13.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1286| 13.3k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 13.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1287| 13.3k| char *source = yyg->yytext_ptr;
------------------
| | 579| 13.3k|#define yytext_ptr yytext_r
------------------
1288| 13.3k| int number_to_move, i;
1289| 13.3k| int ret_val;
1290| |
1291| 13.3k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 13.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1291:7): [True: 0, False: 13.3k]
------------------
1292| 13.3k| 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.3k| "fatal flex scanner internal error--end of buffer missed" );
1294| |
1295| 13.3k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 13.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1295:7): [True: 0, False: 13.3k]
------------------
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.3k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 13.3k|#define yytext_ptr yytext_r
------------------
1318| |
1319| 239M| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1319:15): [True: 239M, False: 13.3k]
------------------
1320| 239M| *(dest++) = *(source++);
1321| |
1322| 13.3k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 13.3k|#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.3k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1322:7): [True: 2.19k, False: 11.1k]
------------------
1323| | /* don't do the read, it's not guaranteed to return an EOF,
1324| | * just force an EOF
1325| | */
1326| 2.19k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 2.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1327| |
1328| 11.1k| else
1329| 11.1k| {
1330| 11.1k| int num_to_read =
1331| 11.1k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 11.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1332| |
1333| 11.2k| while ( num_to_read <= 0 )
------------------
| Branch (1333:11): [True: 85, False: 11.1k]
------------------
1334| 85| { /* Not enough room in the buffer - grow it. */
1335| |
1336| | /* just a shorter name for the current buffer */
1337| 85| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 85|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1338| |
1339| 85| int yy_c_buf_p_offset =
1340| 85| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1341| |
1342| 85| if ( b->yy_is_our_buffer )
------------------
| Branch (1342:9): [True: 85, False: 0]
------------------
1343| 85| {
1344| 85| int new_size = b->yy_buf_size * 2;
1345| |
1346| 85| if ( new_size <= 0 )
------------------
| Branch (1346:10): [True: 0, False: 85]
------------------
1347| 0| b->yy_buf_size += b->yy_buf_size / 8;
1348| 85| else
1349| 85| b->yy_buf_size *= 2;
1350| |
1351| 85| b->yy_ch_buf = (char *)
1352| | /* Include room in for 2 EOB chars. */
1353| 85| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 85|#define yyrealloc igraph_lgl_yyrealloc
------------------
1354| 85| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1355| 85| }
1356| 0| else
1357| | /* Can't grow it, we don't own it. */
1358| 0| b->yy_ch_buf = NULL;
1359| |
1360| 85| if ( ! b->yy_ch_buf )
------------------
| Branch (1360:9): [True: 0, False: 85]
------------------
1361| 85| 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| 85| "fatal error - scanner input buffer overflow" );
1363| |
1364| 85| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1365| |
1366| 85| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 85|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1367| 85| number_to_move - 1;
1368| |
1369| 85| }
1370| |
1371| 11.1k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 895| 11.1k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1371:8): [True: 10.4k, False: 716]
------------------
1372| 10.4k| num_to_read = YY_READ_BUF_SIZE;
------------------
| | 895| 10.4k|#define YY_READ_BUF_SIZE 8192
------------------
1373| |
1374| | /* Read in more data. */
1375| 11.1k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 912| 11.1k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 11.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (912:7): [True: 0, False: 11.1k]
| | ------------------
| | 913| 11.1k| { \
| | 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.1k| else \
| | 926| 11.1k| { \
| | 927| 11.1k| errno=0; \
| | 928| 11.1k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 11.1k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.02k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (928:11): [True: 3.02k, False: 8.16k]
| | | Branch (928:78): [True: 0, False: 3.02k]
| | ------------------
| | 929| 11.1k| { \
| | 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.1k| }\
------------------
1376| 11.1k| yyg->yy_n_chars, num_to_read );
1377| |
1378| 11.1k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 11.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1379| 11.1k| }
1380| |
1381| 13.3k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1381:7): [True: 5.22k, False: 8.16k]
------------------
1382| 5.22k| {
1383| 5.22k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 681| 5.22k|#define YY_MORE_ADJ 0
------------------
| Branch (1383:8): [True: 3.02k, False: 2.19k]
------------------
1384| 3.02k| {
1385| 3.02k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.02k|#define EOB_ACT_END_OF_FILE 1
------------------
1386| 3.02k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.02k|#define yyrestart igraph_lgl_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.02k|#define yyin yyg->yyin_r
------------------
1387| 3.02k| }
1388| |
1389| 2.19k| else
1390| 2.19k| {
1391| 2.19k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 2.19k|#define EOB_ACT_LAST_MATCH 2
------------------
1392| 2.19k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 2.19k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1393| 2.19k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 2.19k|#define YY_BUFFER_EOF_PENDING 2
------------------
1394| 2.19k| }
1395| 5.22k| }
1396| |
1397| 8.16k| else
1398| 8.16k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 8.16k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1399| |
1400| 13.3k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 13.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1400:6): [True: 0, False: 13.3k]
------------------
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.3k| yyg->yy_n_chars += number_to_move;
1412| 13.3k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 13.3k|#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.3k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1413| 13.3k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 13.3k|#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.3k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1414| |
1415| 13.3k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 13.3k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 13.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1416| |
1417| 13.3k| return ret_val;
1418| 13.3k|}
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| 239M| 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: 239M, False: 10.3k]
------------------
1431| 239M| {
1432| 239M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
------------------
| | 346| 239M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1432:19): [True: 239M, False: 0]
------------------
1433| 239M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1433:8): [True: 239M, False: 8.13k]
------------------
1434| 239M| {
1435| 239M| yyg->yy_last_accepting_state = yy_current_state;
1436| 239M| yyg->yy_last_accepting_cpos = yy_cp;
1437| 239M| }
1438| 479M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1438:11): [True: 239M, False: 239M]
------------------
1439| 239M| {
1440| 239M| yy_current_state = (int) yy_def[yy_current_state];
1441| 239M| if ( yy_current_state >= 16 )
------------------
| Branch (1441:9): [True: 239M, False: 3.89k]
------------------
1442| 239M| yy_c = yy_meta[yy_c];
1443| 239M| }
1444| 239M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1445| 239M| }
1446| |
1447| 10.3k| return yy_current_state;
1448| 10.3k|}
lgl-lexer.c:igraph_lgl_yy_load_buffer_state:
1622| 9.08k|{
1623| 9.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1624| 9.08k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 9.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1625| 9.08k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 9.08k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 9.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1626| 9.08k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 9.08k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 9.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1627| 9.08k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1628| 9.08k|}
lgl-lexer.c:igraph_lgl_yy_init_buffer:
1686| 6.05k|{
1687| 6.05k| int oerrno = errno;
1688| 6.05k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1689| |
1690| 6.05k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 6.05k|#define yy_flush_buffer igraph_lgl_yy_flush_buffer
------------------
1691| |
1692| 6.05k| b->yy_input_file = file;
1693| 6.05k| 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.05k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 6.05k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.05k, False: 0]
| | ------------------
| | 522| 6.05k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.05k| : NULL)
------------------
| Branch (1699:9): [True: 3.02k, False: 3.02k]
------------------
1700| 3.02k| b->yy_bs_lineno = 1;
1701| 3.02k| b->yy_bs_column = 0;
1702| 3.02k| }
1703| |
1704| 6.05k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1704:32): [True: 6.05k, False: 0]
------------------
1705| |
1706| | errno = oerrno;
1707| 6.05k|}
lgl-lexer.c:igraph_lgl_yyensure_buffer_stack:
1795| 3.02k|{
1796| 3.02k| yy_size_t num_to_alloc;
1797| 3.02k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1798| |
1799| 3.02k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1799:6): [True: 3.02k, 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.02k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1806| 3.02k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.02k|#define yyalloc igraph_lgl_yyalloc
------------------
1807| 3.02k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1808| 3.02k| , yyscanner);
1809| 3.02k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1809:8): [True: 0, False: 3.02k]
------------------
1810| 3.02k| 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.02k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1813| |
1814| 3.02k| yyg->yy_buffer_stack_max = num_to_alloc;
1815| 3.02k| yyg->yy_buffer_stack_top = 0;
1816| 3.02k| return;
1817| 3.02k| }
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.05k|{
2185| 6.05k| 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.05k| yyg->yy_buffer_stack = NULL;
2191| 6.05k| yyg->yy_buffer_stack_top = 0;
2192| 6.05k| yyg->yy_buffer_stack_max = 0;
2193| 6.05k| yyg->yy_c_buf_p = NULL;
2194| 6.05k| yyg->yy_init = 0;
2195| 6.05k| yyg->yy_start = 0;
2196| |
2197| 6.05k| yyg->yy_start_stack_ptr = 0;
2198| 6.05k| yyg->yy_start_stack_depth = 0;
2199| 6.05k| 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.05k| yyin = NULL;
------------------
| | 356| 6.05k|#define yyin yyg->yyin_r
------------------
2207| 6.05k| yyout = NULL;
------------------
| | 357| 6.05k|#define yyout yyg->yyout_r
------------------
2208| 6.05k|#endif
2209| |
2210| | /* For future reference: Set errno on error, since we are called by
2211| | * yylex_init()
2212| | */
2213| 6.05k| return 0;
2214| 6.05k|}
igraph_lgl_yyparse:
1189| 3.02k|{
1190| |/* The lookahead symbol. */
1191| 3.02k|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.02k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 358| 3.02k|# define YY_INITIAL_VALUE(Value) Value
------------------
1198| 3.02k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 358| 3.02k|# define YY_INITIAL_VALUE(Value) Value
------------------
1199| |
1200| |/* Location data for the lookahead symbol. */
1201| 3.02k|static YYLTYPE yyloc_default
1202| 3.02k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1203| 3.02k| = { 1, 1, 1, 1 }
1204| 3.02k|# endif
1205| 3.02k|;
1206| 3.02k|YYLTYPE yylloc = yyloc_default;
1207| |
1208| | /* Number of syntax errors so far. */
1209| 3.02k| int yynerrs;
1210| |
1211| 3.02k| yy_state_fast_t yystate;
1212| | /* Number of tokens to shift before error messages enabled. */
1213| 3.02k| 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.02k| yy_state_t yyssa[YYINITDEPTH];
1225| 3.02k| yy_state_t *yyss;
1226| 3.02k| yy_state_t *yyssp;
1227| |
1228| | /* The semantic value stack. */
1229| 3.02k| YYSTYPE yyvsa[YYINITDEPTH];
1230| 3.02k| YYSTYPE *yyvs;
1231| 3.02k| YYSTYPE *yyvsp;
1232| |
1233| | /* The location stack. */
1234| 3.02k| YYLTYPE yylsa[YYINITDEPTH];
1235| 3.02k| YYLTYPE *yyls;
1236| 3.02k| YYLTYPE *yylsp;
1237| |
1238| | /* The locations where the error started and ended. */
1239| 3.02k| YYLTYPE yyerror_range[3];
1240| |
1241| 3.02k| YYPTRDIFF_T yystacksize;
------------------
| | 273| 3.02k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1242| |
1243| 3.02k| int yyn;
1244| 3.02k| int yyresult;
1245| | /* Lookahead token as an internal (translated) token number. */
1246| 3.02k| int yytoken = 0;
1247| | /* The variables used to return semantic value and location from the
1248| | action routines. */
1249| 3.02k| YYSTYPE yyval;
1250| 3.02k| YYLTYPE yyloc;
1251| |
1252| 3.02k|#if YYERROR_VERBOSE
1253| | /* Buffer for error messages, and its allocated size. */
1254| 3.02k| char yymsgbuf[128];
1255| 3.02k| char *yymsg = yymsgbuf;
1256| 3.02k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 273| 3.02k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1257| 3.02k|#endif
1258| |
1259| 3.02k|#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.02k| int yylen = 0;
1264| |
1265| 3.02k| yyssp = yyss = yyssa;
1266| 3.02k| yyvsp = yyvs = yyvsa;
1267| 3.02k| yylsp = yyls = yylsa;
1268| 3.02k| yystacksize = YYINITDEPTH;
------------------
| | 914| 3.02k|# define YYINITDEPTH 200
------------------
1269| |
1270| 3.02k| YYDPRINTF ((stderr, "Starting parse\n"));
1271| |
1272| 3.02k| yystate = 0;
1273| 3.02k| yyerrstatus = 0;
1274| 3.02k| yynerrs = 0;
------------------
| | 71| 3.02k|#define yynerrs igraph_lgl_yynerrs
------------------
1275| 3.02k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 678| 3.02k|#define YYEMPTY (-2)
------------------
1276| 3.02k| yylsp[0] = yylloc;
1277| 3.02k| goto yysetstate;
1278| |
1279| |
1280| |/*------------------------------------------------------------.
1281| || yynewstate -- push a new state, which is found in yystate. |
1282| |`------------------------------------------------------------*/
1283| 2.03M|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.03M| yyssp++;
1287| |
1288| |
1289| |/*--------------------------------------------------------------------.
1290| || yysetstate -- set current state (the top of the stack) to yystate. |
1291| |`--------------------------------------------------------------------*/
1292| 2.03M|yysetstate:
1293| 2.03M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1294| 2.03M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 381| 2.03M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (381:31): [Folded, False: 2.03M]
| | | Branch (381:37): [True: 0, False: 0]
| | | Branch (381:37): [True: 0, False: 0]
| | ------------------
------------------
1295| 2.03M| YY_IGNORE_USELESS_CAST_BEGIN
1296| 2.03M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 124| 2.03M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1297| 2.03M| YY_IGNORE_USELESS_CAST_END
1298| |
1299| 2.03M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1299:7): [True: 0, False: 2.03M]
------------------
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.03M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1366| |
1367| 2.03M| if (yystate == YYFINAL)
------------------
| | 515| 2.03M|#define YYFINAL 2
------------------
| Branch (1367:7): [True: 3.02k, False: 2.03M]
------------------
1368| 3.02k| YYACCEPT;
------------------
| | 681| 3.02k|#define YYACCEPT goto yyacceptlab
------------------
1369| |
1370| 2.03M| goto yybackup;
1371| |
1372| |
1373| |/*-----------.
1374| || yybackup. |
1375| |`-----------*/
1376| 2.03M|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.03M| yyn = yypact[yystate];
1382| 2.03M| if (yypact_value_is_default (yyn))
------------------
| | 602| 2.03M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 599| 2.03M|#define YYPACT_NINF (-3)
| | ------------------
| | | Branch (602:3): [True: 1.19M, False: 843k]
| | ------------------
------------------
1383| 1.19M| 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| 843k| if (yychar == YYEMPTY)
------------------
| | 678| 843k|#define YYEMPTY (-2)
------------------
| Branch (1388:7): [True: 830k, False: 12.6k]
------------------
1389| 830k| {
1390| 830k| YYDPRINTF ((stderr, "Reading a token: "));
1391| 830k| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 830k|#define yylex igraph_lgl_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 115| 830k|#define scanner context->scanner
------------------
1392| 830k| }
1393| |
1394| 843k| if (yychar <= YYEOF)
------------------
| | 679| 843k|#define YYEOF 0
------------------
| Branch (1394:7): [True: 5.22k, False: 838k]
------------------
1395| 5.22k| {
1396| 5.22k| yychar = yytoken = YYEOF;
------------------
| | 679| 5.22k|#define YYEOF 0
------------------
1397| 5.22k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1398| 5.22k| }
1399| 838k| else
1400| 838k| {
1401| 838k| yytoken = YYTRANSLATE (yychar);
------------------
| | 535| 838k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 838k|#define YYMAXUTOK 261
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 838k, False: 0]
| | | Branch (535:18): [True: 838k, False: 0]
| | ------------------
------------------
1402| 838k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1403| 838k| }
1404| |
1405| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1406| | detect an error, take that action. */
1407| 843k| yyn += yytoken;
1408| 843k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 517| 843k|#define YYLAST 10
------------------
| Branch (1408:7): [True: 0, False: 843k]
| Branch (1408:18): [True: 0, False: 843k]
| Branch (1408:34): [True: 12.6k, False: 830k]
------------------
1409| 12.6k| goto yydefault;
1410| 830k| yyn = yytable[yyn];
1411| 830k| if (yyn <= 0)
------------------
| Branch (1411:7): [True: 0, False: 830k]
------------------
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| 830k| if (yyerrstatus)
------------------
| Branch (1421:7): [True: 0, False: 830k]
------------------
1422| 0| yyerrstatus--;
1423| |
1424| | /* Shift the lookahead token. */
1425| 830k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1426| 830k| yystate = yyn;
1427| 830k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1428| 830k| *++yyvsp = yylval;
1429| 830k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1430| 830k| *++yylsp = yylloc;
1431| |
1432| | /* Discard the shifted token. */
1433| 830k| yychar = YYEMPTY;
------------------
| | 678| 830k|#define YYEMPTY (-2)
------------------
1434| 830k| goto yynewstate;
1435| |
1436| |
1437| |/*-----------------------------------------------------------.
1438| || yydefault -- do the default action for the current state. |
1439| |`-----------------------------------------------------------*/
1440| 1.20M|yydefault:
1441| 1.20M| yyn = yydefact[yystate];
1442| 1.20M| if (yyn == 0)
------------------
| Branch (1442:7): [True: 0, False: 1.20M]
------------------
1443| 0| goto yyerrlab;
1444| 1.20M| goto yyreduce;
1445| |
1446| |
1447| |/*-----------------------------.
1448| || yyreduce -- do a reduction. |
1449| |`-----------------------------*/
1450| 1.20M|yyreduce:
1451| | /* yyn is the number of a rule to reduce with. */
1452| 1.20M| 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.20M| yyval = yyvsp[1-yylen];
1463| |
1464| | /* Default location. */
1465| 1.20M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 716| 1.20M| do \
| | 717| 1.20M| if (N) \
| | ------------------
| | | Branch (717:11): [True: 1.18M, False: 15.6k]
| | ------------------
| | 718| 1.20M| { \
| | 719| 1.18M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 734| 1.18M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 720| 1.18M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 734| 1.18M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 721| 1.18M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 734| 1.18M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 722| 1.18M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 734| 1.18M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 723| 1.18M| } \
| | 724| 1.20M| else \
| | 725| 1.20M| { \
| | 726| 15.6k| (Current).first_line = (Current).last_line = \
| | 727| 15.6k| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 734| 15.6k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 728| 15.6k| (Current).first_column = (Current).last_column = \
| | 729| 15.6k| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 734| 15.6k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 730| 15.6k| } \
| | 731| 1.20M| while (0)
| | ------------------
| | | Branch (731:12): [Folded, False: 1.20M]
| | ------------------
------------------
1466| 1.20M| yyerror_range[1] = yyloc;
1467| 1.20M| YY_REDUCE_PRINT (yyn);
1468| 1.20M| switch (yyn)
1469| 1.20M| {
1470| 12.6k| case 6:
------------------
| Branch (1470:3): [True: 12.6k, False: 1.19M]
------------------
1471| 12.6k|#line 99 "/src/igraph/src/io/lgl-parser.y"
1472| 12.6k| { context->actvertex=(yyvsp[-1].edgenum); }
1473| 12.6k|#line 1474 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1474| 12.6k| break;
1475| |
1476| 258k| case 9:
------------------
| Branch (1476:3): [True: 258k, False: 946k]
------------------
1477| 258k|#line 103 "/src/igraph/src/io/lgl-parser.y"
1478| 258k| {
1479| 258k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, context->actvertex));
------------------
| | 10| 258k| do { \
| | 11| 258k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 258k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 258k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 258k]
| | | | ------------------
| | ------------------
| | 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| 258k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 258k]
| | ------------------
------------------
1480| 258k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-1].edgenum)));
------------------
| | 10| 258k| do { \
| | 11| 258k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 258k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 258k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 258k]
| | | | ------------------
| | ------------------
| | 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| 258k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 258k]
| | ------------------
------------------
1481| 258k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, 1.0));
------------------
| | 10| 258k| do { \
| | 11| 258k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 258k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 258k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 258k]
| | | | ------------------
| | ------------------
| | 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| 258k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 258k]
| | ------------------
------------------
1482| 258k| }
1483| 258k|#line 1484 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1484| 258k| break;
1485| |
1486| 258k| case 10:
------------------
| Branch (1486:3): [True: 90.9k, False: 1.11M]
------------------
1487| 90.9k|#line 108 "/src/igraph/src/io/lgl-parser.y"
1488| 90.9k| {
1489| 90.9k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, context->actvertex));
------------------
| | 10| 90.9k| do { \
| | 11| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.9k]
| | | | ------------------
| | ------------------
| | 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| 90.9k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 90.9k]
| | ------------------
------------------
1490| 90.9k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-2].edgenum)));
------------------
| | 10| 90.9k| do { \
| | 11| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.9k]
| | | | ------------------
| | ------------------
| | 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| 90.9k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 90.9k]
| | ------------------
------------------
1491| 90.9k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, (yyvsp[-1].weightnum)));
------------------
| | 10| 90.9k| do { \
| | 11| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.9k]
| | | | ------------------
| | ------------------
| | 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| 90.9k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 90.9k]
| | ------------------
------------------
1492| 90.9k| context->has_weights = 1;
1493| 90.9k| }
1494| 0|#line 1495 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1495| 0| break;
1496| |
1497| 362k| case 11:
------------------
| Branch (1497:3): [True: 362k, False: 843k]
------------------
1498| 362k|#line 117 "/src/igraph/src/io/lgl-parser.y"
1499| 362k| {
1500| 362k| igraph_int_t trie_id;
1501| 362k| IGRAPH_YY_CHECK(igraph_trie_get_len(context->trie,
------------------
| | 10| 362k| do { \
| | 11| 362k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 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]
| | | | ------------------
| | ------------------
| | 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| 362k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 362k]
| | ------------------
------------------
1502| 362k| igraph_lgl_yyget_text(scanner),
1503| 362k| igraph_lgl_yyget_leng(scanner),
1504| 362k| &trie_id
1505| 362k| ));
1506| 362k| (yyval.edgenum) = trie_id;
1507| 362k|}
1508| 0|#line 1509 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1509| 0| break;
1510| |
1511| 90.9k| case 12:
------------------
| Branch (1511:3): [True: 90.9k, False: 1.11M]
------------------
1512| 90.9k|#line 127 "/src/igraph/src/io/lgl-parser.y"
1513| 90.9k| {
1514| 90.9k| igraph_real_t val;
1515| 90.9k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_lgl_yyget_text(scanner),
------------------
| | 10| 90.9k| do { \
| | 11| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.9k]
| | | | ------------------
| | ------------------
| | 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| 90.9k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 90.9k]
| | ------------------
------------------
1516| 90.9k| igraph_lgl_yyget_leng(scanner),
1517| 90.9k| &val));
1518| 90.9k| (yyval.weightnum)=val;
1519| 90.9k|}
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| 390k| default: break;
------------------
| Branch (1526:7): [True: 390k, False: 814k]
------------------
1527| 1.20M| }
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.20M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1540| |
1541| 1.20M| YYPOPSTACK (yylen);
------------------
| | 1259| 1.20M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1542| 1.20M| yylen = 0;
1543| 1.20M| YY_STACK_PRINT (yyss, yyssp);
1544| |
1545| 1.20M| *++yyvsp = yyval;
1546| 1.20M| *++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.20M| {
1552| 1.20M| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 520| 1.20M|#define YYNTOKENS 7
------------------
1553| 1.20M| const int yyi = yypgoto[yylhs] + *yyssp;
1554| 1.20M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 517| 2.36M|#define YYLAST 10
------------------
| Branch (1554:16): [True: 1.16M, False: 40.9k]
| Branch (1554:28): [True: 1.16M, False: 0]
| Branch (1554:45): [True: 349k, False: 814k]
------------------
1555| 1.20M| ? yytable[yyi]
1556| 1.20M| : yydefgoto[yylhs]);
1557| 1.20M| }
1558| |
1559| 1.20M| 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.02k|yyacceptlab:
1707| 3.02k| yyresult = 0;
1708| 3.02k| 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.02k|yyreturn:
1734| 3.02k| if (yychar != YYEMPTY)
------------------
| | 678| 3.02k|#define YYEMPTY (-2)
------------------
| Branch (1734:7): [True: 0, False: 3.02k]
------------------
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.02k| YYPOPSTACK (yylen);
------------------
| | 1259| 3.02k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1745| 3.02k| YY_STACK_PRINT (yyss, yyssp);
1746| 9.08k| while (yyssp != yyss)
------------------
| Branch (1746:10): [True: 6.05k, False: 3.02k]
------------------
1747| 6.05k| {
1748| 6.05k| yydestruct ("Cleanup: popping",
1749| 6.05k| yystos[+*yyssp], yyvsp, yylsp, context);
1750| 6.05k| YYPOPSTACK (1);
------------------
| | 1259| 6.05k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1751| 6.05k| }
1752| 3.02k|#ifndef yyoverflow
1753| 3.02k| if (yyss != yyssa)
------------------
| Branch (1753:7): [True: 0, False: 3.02k]
------------------
1754| 0| YYSTACK_FREE (yyss);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1755| 3.02k|#endif
1756| 3.02k|#if YYERROR_VERBOSE
1757| 3.02k| if (yymsg != yymsgbuf)
------------------
| Branch (1757:7): [True: 0, False: 3.02k]
------------------
1758| 0| YYSTACK_FREE (yymsg);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1759| 3.02k|#endif
1760| 3.02k| return yyresult;
1761| 0|}
lgl-parser.c:yydestruct:
1167| 6.05k|{
1168| 6.05k| YYUSE (yyvaluep);
------------------
| | 344| 6.05k|# define YYUSE(E) ((void) (E))
------------------
1169| 6.05k| YYUSE (yylocationp);
------------------
| | 344| 6.05k|# define YYUSE(E) ((void) (E))
------------------
1170| 6.05k| YYUSE (context);
------------------
| | 344| 6.05k|# define YYUSE(E) ((void) (E))
------------------
1171| 6.05k| if (!yymsg)
------------------
| Branch (1171:7): [True: 0, False: 6.05k]
------------------
1172| 0| yymsg = "Deleting";
1173| 6.05k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1174| |
1175| 6.05k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1176| 6.05k| YYUSE (yytype);
------------------
| | 344| 6.05k|# define YYUSE(E) ((void) (E))
------------------
1177| 6.05k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1178| 6.05k|}
igraph_ncol_yylex:
994| 1.14M|{
995| 1.14M| yy_state_type yy_current_state;
996| 1.14M| char *yy_cp, *yy_bp;
997| 1.14M| int yy_act;
998| 1.14M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
999| |
1000| 1.14M| yylval = yylval_param;
------------------
| | 807| 1.14M| # define yylval yyg->yylval_r
------------------
1001| |
1002| 1.14M| yylloc = yylloc_param;
------------------
| | 809| 1.14M| # define yylloc yyg->yylloc_r
------------------
1003| |
1004| 1.14M| if ( !yyg->yy_init )
------------------
| Branch (1004:7): [True: 3.08k, False: 1.14M]
------------------
1005| 3.08k| {
1006| 3.08k| yyg->yy_init = 1;
1007| |
1008| |#ifdef YY_USER_INIT
1009| | YY_USER_INIT;
1010| |#endif
1011| |
1012| 3.08k| if ( ! yyg->yy_start )
------------------
| Branch (1012:8): [True: 3.08k, False: 0]
------------------
1013| 3.08k| yyg->yy_start = 1; /* first start state */
1014| |
1015| 3.08k| if ( ! yyin )
------------------
| | 356| 3.08k|#define yyin yyg->yyin_r
------------------
| Branch (1015:8): [True: 0, False: 3.08k]
------------------
1016| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1017| |
1018| 3.08k| if ( ! yyout )
------------------
| | 357| 3.08k|#define yyout yyg->yyout_r
------------------
| Branch (1018:8): [True: 3.08k, False: 0]
------------------
1019| 3.08k| yyout = stdout;
------------------
| | 357| 3.08k|#define yyout yyg->yyout_r
------------------
1020| |
1021| 3.08k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.08k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.08k]
| | ------------------
| | 522| 3.08k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.08k| : NULL)
------------------
| Branch (1021:8): [True: 3.08k, False: 0]
------------------
1022| 3.08k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.08k|#define yyensure_buffer_stack igraph_ncol_yyensure_buffer_stack
------------------
1023| 3.08k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1024| 3.08k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.08k|#define yy_create_buffer igraph_ncol_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.08k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.08k|#define YY_BUF_SIZE 16384
------------------
1025| 3.08k| }
1026| |
1027| 3.08k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.08k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1028| 3.08k| }
1029| |
1030| 1.14M| {
1031| 1.14M|#line 79 "/src/igraph/src/io/ncol-lexer.l"
1032| |
1033| |
1034| 1.14M|#line 82 "/src/igraph/src/io/ncol-lexer.l"
1035| | /* ------------------------------------------------whitespace------*/
1036| 1.14M|#line 1037 "/src/igraph/build/src/io/parsers/ncol-lexer.c"
1037| |
1038| 1.58M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1038:23): [True: 1.58M, Folded]
------------------
1039| 1.58M| {
1040| 1.58M| yy_cp = yyg->yy_c_buf_p;
1041| |
1042| | /* Support of yytext. */
1043| 1.58M| *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.58M| yy_bp = yy_cp;
1049| |
1050| 1.58M| yy_current_state = yyg->yy_start;
1051| 1.60M|yy_match:
1052| 1.60M| do
1053| 75.2M| {
1054| 75.2M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 75.2M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1055| 75.2M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1055:9): [True: 73.6M, False: 1.59M]
------------------
1056| 73.6M| {
1057| 73.6M| yyg->yy_last_accepting_state = yy_current_state;
1058| 73.6M| yyg->yy_last_accepting_cpos = yy_cp;
1059| 73.6M| }
1060| 151M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1060:12): [True: 76.5M, False: 75.2M]
------------------
1061| 76.5M| {
1062| 76.5M| yy_current_state = (int) yy_def[yy_current_state];
1063| 76.5M| if ( yy_current_state >= 15 )
------------------
| Branch (1063:10): [True: 73.6M, False: 2.83M]
------------------
1064| 73.6M| yy_c = yy_meta[yy_c];
1065| 76.5M| }
1066| 75.2M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1067| 75.2M| ++yy_cp;
1068| 75.2M| }
1069| 75.2M| while ( yy_base[yy_current_state] != 11 );
------------------
| Branch (1069:11): [True: 73.6M, False: 1.60M]
------------------
1070| |
1071| 1.60M|yy_find_action:
1072| 1.60M| yy_act = yy_accept[yy_current_state];
1073| 1.60M| if ( yy_act == 0 )
------------------
| Branch (1073:8): [True: 1.60M, False: 2.25k]
------------------
1074| 1.60M| { /* have to back up */
1075| 1.60M| yy_cp = yyg->yy_last_accepting_cpos;
1076| 1.60M| yy_current_state = yyg->yy_last_accepting_state;
1077| 1.60M| yy_act = yy_accept[yy_current_state];
1078| 1.60M| }
1079| |
1080| 1.60M| YY_DO_BEFORE_ACTION;
------------------
| | 590| 1.60M| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 1.60M|#define yytext_ptr yytext_r
| | ------------------
| | 591| 1.60M| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 1.60M|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 1.60M| yyg->yy_hold_char = *yy_cp; \
| | 593| 1.60M| *yy_cp = '\0'; \
| | 594| 1.60M| yyg->yy_c_buf_p = yy_cp;
------------------
1081| |
1082| 1.60M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 3.20M|#define YY_END_OF_BUFFER 6
------------------
| Branch (1082:8): [True: 1.58M, False: 16.8k]
| Branch (1082:38): [True: 351k, False: 1.23M]
------------------
1083| 351k| {
1084| 351k| int yyl;
1085| 702k| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 702k|#define yyleng yyg->yyleng_r
------------------
| Branch (1085:19): [True: 351k, False: 351k]
------------------
1086| 351k| if ( yytext[yyl] == '\n' )
------------------
| | 360| 351k|#define yytext yyg->yytext_r
------------------
| Branch (1086:10): [True: 351k, False: 0]
------------------
1087| |
1088| 351k| do{ yylineno++;
------------------
| | 361| 351k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 351k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1089| 351k| yycolumn=0;
------------------
| | 362| 351k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 351k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1090| 351k| }while(0)
------------------
| Branch (1090:12): [Folded, False: 351k]
------------------
1091| 351k|;
1092| 351k| }
1093| |
1094| 1.60M|do_action: /* This label is used only to access EOF actions. */
1095| |
1096| 1.60M| switch ( yy_act )
1097| 1.60M| { /* beginning of action switch */
1098| 0| case 0: /* must back up */
------------------
| Branch (1098:4): [True: 0, False: 1.60M]
------------------
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| 441k|case 1:
------------------
| Branch (1105:1): [True: 441k, False: 1.16M]
------------------
1106| 441k|YY_RULE_SETUP
------------------
| | 989| 441k| YY_USER_ACTION
| | ------------------
| | | | 735| 441k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 441k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 441k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 441k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1107| 441k|#line 83 "/src/igraph/src/io/ncol-lexer.l"
1108| 441k|{ /* skip space */ }
1109| 441k| YY_BREAK
------------------
| | 985| 441k|#define YY_BREAK /*LINTED*/break;
------------------
1110| |/* ----------------------------------------------alphanumeric------*/
1111| 792k|case 2:
------------------
| Branch (1111:1): [True: 792k, False: 812k]
------------------
1112| 792k|YY_RULE_SETUP
------------------
| | 989| 792k| YY_USER_ACTION
| | ------------------
| | | | 735| 792k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 792k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 792k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 792k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1113| 792k|#line 86 "/src/igraph/src/io/ncol-lexer.l"
1114| 792k|{ BEGIN(LINE); return ALNUM; }
------------------
| | 369| 792k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return ALNUM; }
------------------
| | 751| 792k|#define LINE 1
------------------
1115| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1116| |/* ---------------------------------------------------newline------*/
1117| 351k|case 3:
------------------
| Branch (1117:1): [True: 351k, False: 1.25M]
------------------
1118| |/* rule 3 can match eol */
1119| 351k|#line 90 "/src/igraph/src/io/ncol-lexer.l"
1120| 351k|YY_RULE_SETUP
------------------
| | 989| 351k| YY_USER_ACTION
| | ------------------
| | | | 735| 351k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 351k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 351k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 351k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1121| 351k|case YY_STATE_EOF(LINE):
------------------
| | 377| 351k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 351k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
| Branch (1121:1): [True: 0, False: 1.60M]
------------------
1122| 351k|#line 90 "/src/igraph/src/io/ncol-lexer.l"
1123| 351k|{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 369| 351k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 750| 351k|#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.60M]
------------------
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.60M]
------------------
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.08k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.08k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.08k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
| Branch (1137:1): [True: 3.08k, False: 1.60M]
------------------
1138| 3.08k| yyterminate();
------------------
| | 948| 3.08k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.08k|#define YY_NULL 0
| | ------------------
------------------
1139| |
1140| 16.8k| case YY_END_OF_BUFFER:
------------------
| | 596| 16.8k|#define YY_END_OF_BUFFER 6
------------------
| Branch (1140:2): [True: 16.8k, False: 1.58M]
------------------
1141| 16.8k| {
1142| | /* Amount of text matched not including the EOB char. */
1143| 16.8k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 16.8k|#define yytext_ptr yytext_r
------------------
1144| |
1145| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1146| 16.8k| *yy_cp = yyg->yy_hold_char;
1147| 16.8k| YY_RESTORE_YY_MORE_OFFSET
1148| |
1149| 16.8k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 16.8k|#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| 16.8k|#define YY_BUFFER_NEW 0
------------------
| Branch (1149:8): [True: 3.08k, False: 13.7k]
------------------
1150| 3.08k| {
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.08k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1161| 3.08k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.08k|#define yyin yyg->yyin_r
------------------
1162| 3.08k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.08k|#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.08k|#define YY_BUFFER_NORMAL 1
------------------
1163| 3.08k| }
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| 16.8k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 16.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1172:8): [True: 0, False: 16.8k]
------------------
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| 16.8k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1208:17): [True: 16.8k, False: 0]
------------------
1209| 16.8k| {
1210| 3.08k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.08k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1210:4): [True: 3.08k, False: 13.7k]
------------------
1211| 3.08k| {
1212| 3.08k| yyg->yy_did_buffer_switch_on_eof = 0;
1213| |
1214| 3.08k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.08k|#define yywrap igraph_ncol_yywrap
| | ------------------
| | | | 573| 3.08k|#define igraph_ncol_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:39): [True: 3.08k, Folded]
| | | | ------------------
| | ------------------
------------------
1215| 3.08k| {
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.08k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.08k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 3.08k|#define YY_MORE_ADJ 0
------------------
1226| |
1227| 3.08k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.08k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.08k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
1228| 3.08k| goto do_action;
1229| 3.08k| }
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.08k| }
1238| |
1239| 11.4k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 11.4k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1239:4): [True: 11.4k, False: 5.33k]
------------------
1240| 11.4k| yyg->yy_c_buf_p =
1241| 11.4k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 11.4k|#define yytext_ptr yytext_r
------------------
1242| |
1243| 11.4k| yy_current_state = yy_get_previous_state( yyscanner );
1244| |
1245| 11.4k| yy_cp = yyg->yy_c_buf_p;
1246| 11.4k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 11.4k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 11.4k|#define YY_MORE_ADJ 0
------------------
1247| 11.4k| goto yy_match;
1248| |
1249| 2.25k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 2.25k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1249:4): [True: 2.25k, False: 14.5k]
------------------
1250| 2.25k| yyg->yy_c_buf_p =
1251| 2.25k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 2.25k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1252| |
1253| 2.25k| yy_current_state = yy_get_previous_state( yyscanner );
1254| |
1255| 2.25k| yy_cp = yyg->yy_c_buf_p;
1256| 2.25k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 2.25k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 2.25k|#define YY_MORE_ADJ 0
------------------
1257| 2.25k| goto yy_find_action;
1258| 16.8k| }
1259| 0| break;
1260| 16.8k| }
1261| |
1262| 0| default:
------------------
| Branch (1262:2): [True: 0, False: 1.60M]
------------------
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.60M| "fatal flex scanner internal error--no action found" );
1265| 1.60M| } /* end of action switch */
1266| 1.60M| } /* end of scanning one token */
1267| 1.14M| } /* end of user's declarations */
1268| 1.14M|} /* end of yylex */
igraph_ncol_yyrestart:
1566| 3.08k|{
1567| 3.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1568| |
1569| 3.08k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.08k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.08k, False: 0]
| | ------------------
| | 522| 3.08k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.08k| : NULL)
------------------
| Branch (1569:7): [True: 0, False: 3.08k]
------------------
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.08k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.08k|#define yy_init_buffer igraph_ncol_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.08k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.08k, False: 0]
| | ------------------
| | 522| 3.08k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.08k| : NULL)
------------------
1576| 3.08k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.08k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1577| 3.08k|}
igraph_ncol_yy_create_buffer:
1631| 3.08k|{
1632| 3.08k| YY_BUFFER_STATE b;
1633| |
1634| 3.08k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.08k|#define yyalloc igraph_ncol_yyalloc
------------------
1635| 3.08k| if ( ! b )
------------------
| Branch (1635:7): [True: 0, False: 3.08k]
------------------
1636| 3.08k| 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.08k| 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.08k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.08k|#define yyalloc igraph_ncol_yyalloc
------------------
1644| 3.08k| if ( ! b->yy_ch_buf )
------------------
| Branch (1644:7): [True: 0, False: 3.08k]
------------------
1645| 3.08k| 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.08k| b->yy_is_our_buffer = 1;
1648| |
1649| 3.08k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.08k|#define yy_init_buffer igraph_ncol_yy_init_buffer
------------------
1650| |
1651| 3.08k| return b;
1652| 3.08k|}
igraph_ncol_yy_delete_buffer:
1659| 3.08k|{
1660| 3.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1661| |
1662| 3.08k| if ( ! b )
------------------
| Branch (1662:7): [True: 0, False: 3.08k]
------------------
1663| 0| return;
1664| |
1665| 3.08k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.08k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.08k, False: 0]
| | ------------------
| | 522| 3.08k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.08k| : NULL)
------------------
| Branch (1665:7): [True: 3.08k, False: 0]
------------------
1666| 3.08k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1667| |
1668| 3.08k| if ( b->yy_is_our_buffer )
------------------
| Branch (1668:7): [True: 3.08k, False: 0]
------------------
1669| 3.08k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.08k|#define yyfree igraph_ncol_yyfree
------------------
1670| |
1671| 3.08k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.08k|#define yyfree igraph_ncol_yyfree
------------------
1672| 3.08k|}
igraph_ncol_yy_flush_buffer:
1708| 6.16k|{
1709| 6.16k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1710| 6.16k| if ( ! b )
------------------
| Branch (1710:7): [True: 0, False: 6.16k]
------------------
1711| 0| return;
1712| |
1713| 6.16k| 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.16k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.16k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1720| 6.16k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.16k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1721| |
1722| 6.16k| b->yy_buf_pos = &b->yy_ch_buf[0];
1723| |
1724| 6.16k| b->yy_at_bol = 1;
1725| 6.16k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 6.16k|#define YY_BUFFER_NEW 0
------------------
1726| |
1727| 6.16k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 6.16k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.16k, False: 0]
| | ------------------
| | 522| 6.16k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.16k| : NULL)
------------------
| Branch (1727:7): [True: 3.08k, False: 3.08k]
------------------
1728| 3.08k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.08k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1729| 6.16k|}
igraph_ncol_yypop_buffer_state:
1769| 3.08k|{
1770| 3.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1771| 3.08k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.08k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.08k, False: 0]
| | ------------------
| | 522| 3.08k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.08k| : NULL)
------------------
| Branch (1771:6): [True: 3.08k, False: 0]
------------------
1772| 3.08k| 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| 792k|{
2007| 792k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2008| 792k| return yyleng;
------------------
| | 359| 792k|#define yyleng yyg->yyleng_r
------------------
2009| 792k|}
igraph_ncol_yyget_text:
2016| 792k|{
2017| 792k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2018| 792k| return yytext;
------------------
| | 360| 792k|#define yytext yyg->yytext_r
------------------
2019| 792k|}
igraph_ncol_yyset_extra:
2026| 6.16k|{
2027| 6.16k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2028| 6.16k| yyextra = user_defined ;
------------------
| | 358| 6.16k|#define yyextra yyg->yyextra_r
------------------
2029| 6.16k|}
igraph_ncol_yyset_in:
2068| 3.08k|{
2069| 3.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2070| 3.08k| yyin = _in_str ;
------------------
| | 356| 3.08k|#define yyin yyg->yyin_r
------------------
2071| 3.08k|}
igraph_ncol_yylex_init_extra:
2151| 3.08k|{
2152| 3.08k| struct yyguts_t dummy_yyguts;
2153| |
2154| 3.08k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.08k|#define yyset_extra igraph_ncol_yyset_extra
------------------
2155| |
2156| 3.08k| if (ptr_yy_globals == NULL){
------------------
| Branch (2156:9): [True: 0, False: 3.08k]
------------------
2157| 0| errno = EINVAL;
2158| 0| return 1;
2159| 0| }
2160| |
2161| 3.08k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.08k|#define yyalloc igraph_ncol_yyalloc
------------------
2162| |
2163| 3.08k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2163:9): [True: 0, False: 3.08k]
------------------
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.08k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2171| |
2172| 3.08k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.08k|#define yyset_extra igraph_ncol_yyset_extra
------------------
2173| |
2174| 3.08k| return yy_init_globals ( *ptr_yy_globals );
2175| 3.08k|}
igraph_ncol_yylex_destroy:
2212| 3.08k|{
2213| 3.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2214| |
2215| | /* Pop the buffer stack, destroying each element. */
2216| 6.16k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 6.16k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.08k, False: 3.08k]
| | | Branch (521:29): [True: 6.16k, False: 0]
| | ------------------
| | 522| 6.16k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.16k| : NULL)
------------------
2217| 3.08k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.08k|#define yy_delete_buffer igraph_ncol_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.08k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.08k, False: 0]
| | ------------------
| | 522| 3.08k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.08k| : NULL)
------------------
2218| 3.08k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.08k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2219| 3.08k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.08k|#define yypop_buffer_state igraph_ncol_yypop_buffer_state
------------------
2220| 3.08k| }
2221| |
2222| | /* Destroy the stack itself. */
2223| 3.08k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.08k|#define yyfree igraph_ncol_yyfree
------------------
2224| 3.08k| yyg->yy_buffer_stack = NULL;
2225| |
2226| | /* Destroy the start condition stack. */
2227| 3.08k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.08k|#define yyfree igraph_ncol_yyfree
------------------
2228| 3.08k| 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.08k| yy_init_globals( yyscanner);
2233| |
2234| | /* Destroy the main struct (reentrant only). */
2235| 3.08k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.08k|#define yyfree igraph_ncol_yyfree
------------------
2236| | yyscanner = NULL;
2237| 3.08k| return 0;
2238| 3.08k|}
igraph_ncol_yyalloc:
2268| 12.3k|{
2269| 12.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2270| 12.3k| (void)yyg;
2271| 12.3k| return malloc(size);
2272| 12.3k|}
igraph_ncol_yyrealloc:
2275| 85|{
2276| 85| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2277| 85| (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| 85| return realloc(ptr, size);
2287| 85|}
igraph_ncol_yyfree:
2290| 15.4k|{
2291| 15.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2292| 15.4k| (void)yyg;
2293| 15.4k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2294| 15.4k|}
ncol-lexer.c:yy_get_next_buffer:
1278| 16.8k|{
1279| 16.8k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1280| 16.8k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 16.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1281| 16.8k| char *source = yyg->yytext_ptr;
------------------
| | 579| 16.8k|#define yytext_ptr yytext_r
------------------
1282| 16.8k| int number_to_move, i;
1283| 16.8k| int ret_val;
1284| |
1285| 16.8k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 16.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1285:7): [True: 0, False: 16.8k]
------------------
1286| 16.8k| 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| 16.8k| "fatal flex scanner internal error--end of buffer missed" );
1288| |
1289| 16.8k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 16.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1289:7): [True: 0, False: 16.8k]
------------------
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| 16.8k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 16.8k|#define yytext_ptr yytext_r
------------------
1312| |
1313| 249M| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1313:15): [True: 249M, False: 16.8k]
------------------
1314| 249M| *(dest++) = *(source++);
1315| |
1316| 16.8k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 16.8k|#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| 16.8k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1316:7): [True: 2.25k, False: 14.5k]
------------------
1317| | /* don't do the read, it's not guaranteed to return an EOF,
1318| | * just force an EOF
1319| | */
1320| 2.25k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 2.25k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1321| |
1322| 14.5k| else
1323| 14.5k| {
1324| 14.5k| int num_to_read =
1325| 14.5k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 14.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1326| |
1327| 14.6k| while ( num_to_read <= 0 )
------------------
| Branch (1327:11): [True: 85, False: 14.5k]
------------------
1328| 85| { /* Not enough room in the buffer - grow it. */
1329| |
1330| | /* just a shorter name for the current buffer */
1331| 85| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 85|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1332| |
1333| 85| int yy_c_buf_p_offset =
1334| 85| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1335| |
1336| 85| if ( b->yy_is_our_buffer )
------------------
| Branch (1336:9): [True: 85, False: 0]
------------------
1337| 85| {
1338| 85| int new_size = b->yy_buf_size * 2;
1339| |
1340| 85| if ( new_size <= 0 )
------------------
| Branch (1340:10): [True: 0, False: 85]
------------------
1341| 0| b->yy_buf_size += b->yy_buf_size / 8;
1342| 85| else
1343| 85| b->yy_buf_size *= 2;
1344| |
1345| 85| b->yy_ch_buf = (char *)
1346| | /* Include room in for 2 EOB chars. */
1347| 85| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 85|#define yyrealloc igraph_ncol_yyrealloc
------------------
1348| 85| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1349| 85| }
1350| 0| else
1351| | /* Can't grow it, we don't own it. */
1352| 0| b->yy_ch_buf = NULL;
1353| |
1354| 85| if ( ! b->yy_ch_buf )
------------------
| Branch (1354:9): [True: 0, False: 85]
------------------
1355| 85| 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| 85| "fatal error - scanner input buffer overflow" );
1357| |
1358| 85| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1359| |
1360| 85| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 85|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1361| 85| number_to_move - 1;
1362| |
1363| 85| }
1364| |
1365| 14.5k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 895| 14.5k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1365:8): [True: 13.4k, False: 1.12k]
------------------
1366| 13.4k| num_to_read = YY_READ_BUF_SIZE;
------------------
| | 895| 13.4k|#define YY_READ_BUF_SIZE 8192
------------------
1367| |
1368| | /* Read in more data. */
1369| 14.5k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 912| 14.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 14.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (912:7): [True: 0, False: 14.5k]
| | ------------------
| | 913| 14.5k| { \
| | 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.5k| else \
| | 926| 14.5k| { \
| | 927| 14.5k| errno=0; \
| | 928| 14.5k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 14.5k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.08k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (928:11): [True: 3.08k, False: 11.4k]
| | | Branch (928:78): [True: 0, False: 3.08k]
| | ------------------
| | 929| 14.5k| { \
| | 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.5k| }\
------------------
1370| 14.5k| yyg->yy_n_chars, num_to_read );
1371| |
1372| 14.5k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 14.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1373| 14.5k| }
1374| |
1375| 16.8k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1375:7): [True: 5.33k, False: 11.4k]
------------------
1376| 5.33k| {
1377| 5.33k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 681| 5.33k|#define YY_MORE_ADJ 0
------------------
| Branch (1377:8): [True: 3.08k, False: 2.25k]
------------------
1378| 3.08k| {
1379| 3.08k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.08k|#define EOB_ACT_END_OF_FILE 1
------------------
1380| 3.08k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.08k|#define yyrestart igraph_ncol_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.08k|#define yyin yyg->yyin_r
------------------
1381| 3.08k| }
1382| |
1383| 2.25k| else
1384| 2.25k| {
1385| 2.25k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 2.25k|#define EOB_ACT_LAST_MATCH 2
------------------
1386| 2.25k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 2.25k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1387| 2.25k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 2.25k|#define YY_BUFFER_EOF_PENDING 2
------------------
1388| 2.25k| }
1389| 5.33k| }
1390| |
1391| 11.4k| else
1392| 11.4k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 11.4k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1393| |
1394| 16.8k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 16.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1394:6): [True: 0, False: 16.8k]
------------------
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| 16.8k| yyg->yy_n_chars += number_to_move;
1406| 16.8k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 16.8k|#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| 16.8k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1407| 16.8k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 16.8k|#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| 16.8k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1408| |
1409| 16.8k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 16.8k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 16.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1410| |
1411| 16.8k| return ret_val;
1412| 16.8k|}
ncol-lexer.c:yy_get_previous_state:
1417| 13.7k|{
1418| 13.7k| yy_state_type yy_current_state;
1419| 13.7k| char *yy_cp;
1420| 13.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1421| |
1422| 13.7k| yy_current_state = yyg->yy_start;
1423| |
1424| 249M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 579| 13.7k|#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.7k|#define YY_MORE_ADJ 0
------------------
| Branch (1424:47): [True: 249M, False: 13.7k]
------------------
1425| 249M| {
1426| 249M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
------------------
| | 346| 249M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1426:19): [True: 249M, False: 0]
------------------
1427| 249M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1427:8): [True: 249M, False: 11.4k]
------------------
1428| 249M| {
1429| 249M| yyg->yy_last_accepting_state = yy_current_state;
1430| 249M| yyg->yy_last_accepting_cpos = yy_cp;
1431| 249M| }
1432| 499M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1432:11): [True: 249M, False: 249M]
------------------
1433| 249M| {
1434| 249M| yy_current_state = (int) yy_def[yy_current_state];
1435| 249M| if ( yy_current_state >= 15 )
------------------
| Branch (1435:9): [True: 249M, False: 6.94k]
------------------
1436| 249M| yy_c = yy_meta[yy_c];
1437| 249M| }
1438| 249M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1439| 249M| }
1440| |
1441| 13.7k| return yy_current_state;
1442| 13.7k|}
ncol-lexer.c:igraph_ncol_yy_load_buffer_state:
1616| 9.24k|{
1617| 9.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1618| 9.24k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 9.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1619| 9.24k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 9.24k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 9.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1620| 9.24k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 9.24k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 9.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1621| 9.24k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1622| 9.24k|}
ncol-lexer.c:igraph_ncol_yy_init_buffer:
1680| 6.16k|{
1681| 6.16k| int oerrno = errno;
1682| 6.16k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1683| |
1684| 6.16k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 6.16k|#define yy_flush_buffer igraph_ncol_yy_flush_buffer
------------------
1685| |
1686| 6.16k| b->yy_input_file = file;
1687| 6.16k| 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.16k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 6.16k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.16k, False: 0]
| | ------------------
| | 522| 6.16k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.16k| : NULL)
------------------
| Branch (1693:9): [True: 3.08k, False: 3.08k]
------------------
1694| 3.08k| b->yy_bs_lineno = 1;
1695| 3.08k| b->yy_bs_column = 0;
1696| 3.08k| }
1697| |
1698| 6.16k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1698:32): [True: 6.16k, False: 0]
------------------
1699| |
1700| | errno = oerrno;
1701| 6.16k|}
ncol-lexer.c:igraph_ncol_yyensure_buffer_stack:
1789| 3.08k|{
1790| 3.08k| yy_size_t num_to_alloc;
1791| 3.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1792| |
1793| 3.08k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1793:6): [True: 3.08k, 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.08k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1800| 3.08k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.08k|#define yyalloc igraph_ncol_yyalloc
------------------
1801| 3.08k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1802| 3.08k| , yyscanner);
1803| 3.08k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1803:8): [True: 0, False: 3.08k]
------------------
1804| 3.08k| 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.08k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1807| |
1808| 3.08k| yyg->yy_buffer_stack_max = num_to_alloc;
1809| 3.08k| yyg->yy_buffer_stack_top = 0;
1810| 3.08k| return;
1811| 3.08k| }
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.16k|{
2179| 6.16k| 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.16k| yyg->yy_buffer_stack = NULL;
2185| 6.16k| yyg->yy_buffer_stack_top = 0;
2186| 6.16k| yyg->yy_buffer_stack_max = 0;
2187| 6.16k| yyg->yy_c_buf_p = NULL;
2188| 6.16k| yyg->yy_init = 0;
2189| 6.16k| yyg->yy_start = 0;
2190| |
2191| 6.16k| yyg->yy_start_stack_ptr = 0;
2192| 6.16k| yyg->yy_start_stack_depth = 0;
2193| 6.16k| 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.16k| yyin = NULL;
------------------
| | 356| 6.16k|#define yyin yyg->yyin_r
------------------
2201| 6.16k| yyout = NULL;
------------------
| | 357| 6.16k|#define yyout yyg->yyout_r
------------------
2202| 6.16k|#endif
2203| |
2204| | /* For future reference: Set errno on error, since we are called by
2205| | * yylex_init()
2206| | */
2207| 6.16k| return 0;
2208| 6.16k|}
igraph_ncol_yyparse:
1184| 3.08k|{
1185| |/* The lookahead symbol. */
1186| 3.08k|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.08k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 358| 3.08k|# define YY_INITIAL_VALUE(Value) Value
------------------
1193| 3.08k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 358| 3.08k|# define YY_INITIAL_VALUE(Value) Value
------------------
1194| |
1195| |/* Location data for the lookahead symbol. */
1196| 3.08k|static YYLTYPE yyloc_default
1197| 3.08k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1198| 3.08k| = { 1, 1, 1, 1 }
1199| 3.08k|# endif
1200| 3.08k|;
1201| 3.08k|YYLTYPE yylloc = yyloc_default;
1202| |
1203| | /* Number of syntax errors so far. */
1204| 3.08k| int yynerrs;
1205| |
1206| 3.08k| yy_state_fast_t yystate;
1207| | /* Number of tokens to shift before error messages enabled. */
1208| 3.08k| 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.08k| yy_state_t yyssa[YYINITDEPTH];
1220| 3.08k| yy_state_t *yyss;
1221| 3.08k| yy_state_t *yyssp;
1222| |
1223| | /* The semantic value stack. */
1224| 3.08k| YYSTYPE yyvsa[YYINITDEPTH];
1225| 3.08k| YYSTYPE *yyvs;
1226| 3.08k| YYSTYPE *yyvsp;
1227| |
1228| | /* The location stack. */
1229| 3.08k| YYLTYPE yylsa[YYINITDEPTH];
1230| 3.08k| YYLTYPE *yyls;
1231| 3.08k| YYLTYPE *yylsp;
1232| |
1233| | /* The locations where the error started and ended. */
1234| 3.08k| YYLTYPE yyerror_range[3];
1235| |
1236| 3.08k| YYPTRDIFF_T yystacksize;
------------------
| | 273| 3.08k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1237| |
1238| 3.08k| int yyn;
1239| 3.08k| int yyresult;
1240| | /* Lookahead token as an internal (translated) token number. */
1241| 3.08k| int yytoken = 0;
1242| | /* The variables used to return semantic value and location from the
1243| | action routines. */
1244| 3.08k| YYSTYPE yyval;
1245| 3.08k| YYLTYPE yyloc;
1246| |
1247| 3.08k|#if YYERROR_VERBOSE
1248| | /* Buffer for error messages, and its allocated size. */
1249| 3.08k| char yymsgbuf[128];
1250| 3.08k| char *yymsg = yymsgbuf;
1251| 3.08k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 273| 3.08k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1252| 3.08k|#endif
1253| |
1254| 3.08k|#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.08k| int yylen = 0;
1259| |
1260| 3.08k| yyssp = yyss = yyssa;
1261| 3.08k| yyvsp = yyvs = yyvsa;
1262| 3.08k| yylsp = yyls = yylsa;
1263| 3.08k| yystacksize = YYINITDEPTH;
------------------
| | 909| 3.08k|# define YYINITDEPTH 200
------------------
1264| |
1265| 3.08k| YYDPRINTF ((stderr, "Starting parse\n"));
1266| |
1267| 3.08k| yystate = 0;
1268| 3.08k| yyerrstatus = 0;
1269| 3.08k| yynerrs = 0;
------------------
| | 71| 3.08k|#define yynerrs igraph_ncol_yynerrs
------------------
1270| 3.08k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 673| 3.08k|#define YYEMPTY (-2)
------------------
1271| 3.08k| yylsp[0] = yylloc;
1272| 3.08k| goto yysetstate;
1273| |
1274| |
1275| |/*------------------------------------------------------------.
1276| || yynewstate -- push a new state, which is found in yystate. |
1277| |`------------------------------------------------------------*/
1278| 2.99M|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.99M| yyssp++;
1282| |
1283| |
1284| |/*--------------------------------------------------------------------.
1285| || yysetstate -- set current state (the top of the stack) to yystate. |
1286| |`--------------------------------------------------------------------*/
1287| 2.99M|yysetstate:
1288| 2.99M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1289| 2.99M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 381| 2.99M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (381:31): [Folded, False: 2.99M]
| | | Branch (381:37): [True: 0, False: 0]
| | | Branch (381:37): [True: 0, False: 0]
| | ------------------
------------------
1290| 2.99M| YY_IGNORE_USELESS_CAST_BEGIN
1291| 2.99M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 125| 2.99M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1292| 2.99M| YY_IGNORE_USELESS_CAST_END
1293| |
1294| 2.99M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1294:7): [True: 0, False: 2.99M]
------------------
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.99M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1361| |
1362| 2.99M| if (yystate == YYFINAL)
------------------
| | 515| 2.99M|#define YYFINAL 2
------------------
| Branch (1362:7): [True: 3.08k, False: 2.99M]
------------------
1363| 3.08k| YYACCEPT;
------------------
| | 676| 3.08k|#define YYACCEPT goto yyacceptlab
------------------
1364| |
1365| 2.99M| goto yybackup;
1366| |
1367| |
1368| |/*-----------.
1369| || yybackup. |
1370| |`-----------*/
1371| 2.99M|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.99M| yyn = yypact[yystate];
1377| 2.99M| if (yypact_value_is_default (yyn))
------------------
| | 601| 2.99M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 598| 2.99M|#define YYPACT_NINF (-3)
| | ------------------
| | | Branch (601:3): [True: 1.84M, False: 1.14M]
| | ------------------
------------------
1378| 1.84M| 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.14M| if (yychar == YYEMPTY)
------------------
| | 673| 1.14M|#define YYEMPTY (-2)
------------------
| Branch (1383:7): [True: 1.14M, False: 0]
------------------
1384| 1.14M| {
1385| 1.14M| YYDPRINTF ((stderr, "Reading a token: "));
1386| 1.14M| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 1.14M|#define yylex igraph_ncol_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 116| 1.14M|#define scanner context->scanner
------------------
1387| 1.14M| }
1388| |
1389| 1.14M| if (yychar <= YYEOF)
------------------
| | 674| 1.14M|#define YYEOF 0
------------------
| Branch (1389:7): [True: 3.08k, False: 1.14M]
------------------
1390| 3.08k| {
1391| 3.08k| yychar = yytoken = YYEOF;
------------------
| | 674| 3.08k|#define YYEOF 0
------------------
1392| 3.08k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1393| 3.08k| }
1394| 1.14M| else
1395| 1.14M| {
1396| 1.14M| yytoken = YYTRANSLATE (yychar);
------------------
| | 535| 1.14M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 1.14M|#define YYMAXUTOK 260
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 1.14M, False: 0]
| | | Branch (535:18): [True: 1.14M, False: 0]
| | ------------------
------------------
1397| 1.14M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1398| 1.14M| }
1399| |
1400| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1401| | detect an error, take that action. */
1402| 1.14M| yyn += yytoken;
1403| 1.14M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 517| 1.14M|#define YYLAST 7
------------------
| Branch (1403:7): [True: 0, False: 1.14M]
| Branch (1403:18): [True: 0, False: 1.14M]
| Branch (1403:34): [True: 0, False: 1.14M]
------------------
1404| 0| goto yydefault;
1405| 1.14M| yyn = yytable[yyn];
1406| 1.14M| if (yyn <= 0)
------------------
| Branch (1406:7): [True: 0, False: 1.14M]
------------------
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.14M| if (yyerrstatus)
------------------
| Branch (1416:7): [True: 0, False: 1.14M]
------------------
1417| 0| yyerrstatus--;
1418| |
1419| | /* Shift the lookahead token. */
1420| 1.14M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1421| 1.14M| yystate = yyn;
1422| 1.14M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1423| 1.14M| *++yyvsp = yylval;
1424| 1.14M| YY_IGNORE_MAYBE_UNINITIALIZED_END
1425| 1.14M| *++yylsp = yylloc;
1426| |
1427| | /* Discard the shifted token. */
1428| 1.14M| yychar = YYEMPTY;
------------------
| | 673| 1.14M|#define YYEMPTY (-2)
------------------
1429| 1.14M| goto yynewstate;
1430| |
1431| |
1432| |/*-----------------------------------------------------------.
1433| || yydefault -- do the default action for the current state. |
1434| |`-----------------------------------------------------------*/
1435| 1.84M|yydefault:
1436| 1.84M| yyn = yydefact[yystate];
1437| 1.84M| if (yyn == 0)
------------------
| Branch (1437:7): [True: 0, False: 1.84M]
------------------
1438| 0| goto yyerrlab;
1439| 1.84M| goto yyreduce;
1440| |
1441| |
1442| |/*-----------------------------.
1443| || yyreduce -- do a reduction. |
1444| |`-----------------------------*/
1445| 1.84M|yyreduce:
1446| | /* yyn is the number of a rule to reduce with. */
1447| 1.84M| 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.84M| yyval = yyvsp[1-yylen];
1458| |
1459| | /* Default location. */
1460| 1.84M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 711| 1.84M| do \
| | 712| 1.84M| if (N) \
| | ------------------
| | | Branch (712:11): [True: 1.84M, False: 3.08k]
| | ------------------
| | 713| 1.84M| { \
| | 714| 1.84M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 729| 1.84M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 715| 1.84M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 729| 1.84M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 716| 1.84M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 729| 1.84M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 717| 1.84M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 729| 1.84M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 718| 1.84M| } \
| | 719| 1.84M| else \
| | 720| 1.84M| { \
| | 721| 3.08k| (Current).first_line = (Current).last_line = \
| | 722| 3.08k| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 729| 3.08k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 723| 3.08k| (Current).first_column = (Current).last_column = \
| | 724| 3.08k| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 729| 3.08k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 725| 3.08k| } \
| | 726| 1.84M| while (0)
| | ------------------
| | | Branch (726:12): [Folded, False: 1.84M]
| | ------------------
------------------
1461| 1.84M| yyerror_range[1] = yyloc;
1462| 1.84M| YY_REDUCE_PRINT (yyn);
1463| 1.84M| switch (yyn)
1464| 1.84M| {
1465| 260k| case 5:
------------------
| Branch (1465:3): [True: 260k, False: 1.58M]
------------------
1466| 260k|#line 97 "/src/igraph/src/io/ncol-parser.y"
1467| 260k| {
1468| 260k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, 1.0));
------------------
| | 10| 260k| do { \
| | 11| 260k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 260k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 260k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 260k]
| | | | ------------------
| | ------------------
| | 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| 260k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 260k]
| | ------------------
------------------
1469| 260k| }
1470| 260k|#line 1471 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1471| 260k| break;
1472| |
1473| 260k| case 6:
------------------
| Branch (1473:3): [True: 90.9k, False: 1.75M]
------------------
1474| 90.9k|#line 100 "/src/igraph/src/io/ncol-parser.y"
1475| 90.9k| {
1476| 90.9k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, (yyvsp[-1].weightnum)));
------------------
| | 10| 90.9k| do { \
| | 11| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.9k]
| | | | ------------------
| | ------------------
| | 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| 90.9k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 90.9k]
| | ------------------
------------------
1477| 90.9k| context->has_weights = true;
1478| 90.9k| }
1479| 0|#line 1480 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1480| 0| break;
1481| |
1482| 351k| case 7:
------------------
| Branch (1482:3): [True: 351k, False: 1.49M]
------------------
1483| 351k|#line 106 "/src/igraph/src/io/ncol-parser.y"
1484| 351k| {
1485| 351k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-1].edgenum)));
------------------
| | 10| 351k| do { \
| | 11| 351k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 351k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 351k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 351k]
| | | | ------------------
| | ------------------
| | 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| 351k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 351k]
| | ------------------
------------------
1486| 351k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[0].edgenum)));
------------------
| | 10| 351k| do { \
| | 11| 351k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 351k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 351k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 351k]
| | | | ------------------
| | ------------------
| | 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| 351k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 351k]
| | ------------------
------------------
1487| 351k|}
1488| 351k|#line 1489 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1489| 351k| break;
1490| |
1491| 702k| case 8:
------------------
| Branch (1491:3): [True: 702k, False: 1.14M]
------------------
1492| 702k|#line 111 "/src/igraph/src/io/ncol-parser.y"
1493| 702k| {
1494| 702k| igraph_int_t trie_id;
1495| 702k| IGRAPH_YY_CHECK(igraph_trie_get_len(context->trie,
------------------
| | 10| 702k| do { \
| | 11| 702k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 702k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 702k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 702k]
| | | | ------------------
| | ------------------
| | 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| 702k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 702k]
| | ------------------
------------------
1496| 702k| igraph_ncol_yyget_text(scanner),
1497| 702k| igraph_ncol_yyget_leng(scanner),
1498| 702k| &trie_id
1499| 702k| ));
1500| 702k| (yyval.edgenum) = trie_id;
1501| 702k|}
1502| 0|#line 1503 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1503| 0| break;
1504| |
1505| 90.9k| case 9:
------------------
| Branch (1505:3): [True: 90.9k, False: 1.75M]
------------------
1506| 90.9k|#line 121 "/src/igraph/src/io/ncol-parser.y"
1507| 90.9k| {
1508| 90.9k| igraph_real_t val;
1509| 90.9k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_ncol_yyget_text(scanner),
------------------
| | 10| 90.9k| do { \
| | 11| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.9k]
| | | | ------------------
| | ------------------
| | 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| 90.9k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 90.9k]
| | ------------------
------------------
1510| 90.9k| igraph_ncol_yyget_leng(scanner),
1511| 90.9k| &val));
1512| 90.9k| (yyval.weightnum)=val;
1513| 90.9k|}
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| 354k| default: break;
------------------
| Branch (1520:7): [True: 354k, False: 1.49M]
------------------
1521| 1.84M| }
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.84M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1534| |
1535| 1.84M| YYPOPSTACK (yylen);
------------------
| | 1254| 1.84M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1536| 1.84M| yylen = 0;
1537| 1.84M| YY_STACK_PRINT (yyss, yyssp);
1538| |
1539| 1.84M| *++yyvsp = yyval;
1540| 1.84M| *++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.84M| {
1546| 1.84M| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 520| 1.84M|#define YYNTOKENS 6
------------------
1547| 1.84M| const int yyi = yypgoto[yylhs] + *yyssp;
1548| 1.84M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 517| 2.64M|#define YYLAST 7
------------------
| Branch (1548:16): [True: 792k, False: 1.05M]
| Branch (1548:28): [True: 792k, False: 0]
| Branch (1548:45): [True: 351k, False: 441k]
------------------
1549| 1.84M| ? yytable[yyi]
1550| 1.84M| : yydefgoto[yylhs]);
1551| 1.84M| }
1552| |
1553| 1.84M| 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.08k|yyacceptlab:
1701| 3.08k| yyresult = 0;
1702| 3.08k| 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.08k|yyreturn:
1728| 3.08k| if (yychar != YYEMPTY)
------------------
| | 673| 3.08k|#define YYEMPTY (-2)
------------------
| Branch (1728:7): [True: 0, False: 3.08k]
------------------
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.08k| YYPOPSTACK (yylen);
------------------
| | 1254| 3.08k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1739| 3.08k| YY_STACK_PRINT (yyss, yyssp);
1740| 9.24k| while (yyssp != yyss)
------------------
| Branch (1740:10): [True: 6.16k, False: 3.08k]
------------------
1741| 6.16k| {
1742| 6.16k| yydestruct ("Cleanup: popping",
1743| 6.16k| yystos[+*yyssp], yyvsp, yylsp, context);
1744| 6.16k| YYPOPSTACK (1);
------------------
| | 1254| 6.16k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1745| 6.16k| }
1746| 3.08k|#ifndef yyoverflow
1747| 3.08k| if (yyss != yyssa)
------------------
| Branch (1747:7): [True: 0, False: 3.08k]
------------------
1748| 0| YYSTACK_FREE (yyss);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1749| 3.08k|#endif
1750| 3.08k|#if YYERROR_VERBOSE
1751| 3.08k| if (yymsg != yymsgbuf)
------------------
| Branch (1751:7): [True: 0, False: 3.08k]
------------------
1752| 0| YYSTACK_FREE (yymsg);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1753| 3.08k|#endif
1754| 3.08k| return yyresult;
1755| 0|}
ncol-parser.c:yydestruct:
1162| 6.16k|{
1163| 6.16k| YYUSE (yyvaluep);
------------------
| | 344| 6.16k|# define YYUSE(E) ((void) (E))
------------------
1164| 6.16k| YYUSE (yylocationp);
------------------
| | 344| 6.16k|# define YYUSE(E) ((void) (E))
------------------
1165| 6.16k| YYUSE (context);
------------------
| | 344| 6.16k|# define YYUSE(E) ((void) (E))
------------------
1166| 6.16k| if (!yymsg)
------------------
| Branch (1166:7): [True: 0, False: 6.16k]
------------------
1167| 0| yymsg = "Deleting";
1168| 6.16k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1169| |
1170| 6.16k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1171| 6.16k| YYUSE (yytype);
------------------
| | 344| 6.16k|# define YYUSE(E) ((void) (E))
------------------
1172| 6.16k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1173| 6.16k|}
LLVMFuzzerTestOneInput:
36| 19.1k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
37| |
38| 19.1k| igraph_set_error_handler(igraph_error_handler_ignore);
39| 19.1k| igraph_set_warning_handler(igraph_warning_handler_ignore);
40| |
41| | // Turn on attribute handling
42| 19.1k| igraph_set_attribute_table(&igraph_cattribute_table);
43| |
44| | // Read input file
45| 19.1k| FILE *ifile = fmemopen((void*) data, size, "r");
46| 19.1k| if (!ifile) {
------------------
| Branch (46:9): [True: 0, False: 19.1k]
------------------
47| 0| return 0;
48| 0| }
49| |
50| | // Do the fuzzing
51| 19.1k| igraph_t g;
52| 19.1k| if (igraph_read_graph_graphml(&g, ifile, 0) == IGRAPH_SUCCESS) {
------------------
| Branch (52:9): [True: 3.17k, False: 15.9k]
------------------
53| 3.17k| FILE *file;
54| 3.17k| igraph_t g2;
55| |
56| 3.17k| file = tmpfile();
57| 3.17k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.17k| do { \
| | 925| 3.17k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.17k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.17k]
| | ------------------
------------------
58| | // Do not check error because:
59| | // "Vertex attribute values cannot contain newline characters."
60| 3.17k| igraph_write_graph_leda(&g, file, "label", "weight");
61| 3.17k| fclose(file);
62| |
63| 3.17k| file = tmpfile();
64| 3.17k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.17k| do { \
| | 925| 3.17k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.17k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.17k]
| | ------------------
------------------
65| 3.17k| CHECK_ERR(igraph_write_graph_dot(&g, file));
------------------
| | 29| 3.17k| do { \
| | 30| 3.17k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.17k| expr; \
| | 32| 3.17k| igraph_set_error_handler(handler); \
| | 33| 3.17k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.17k]
| | ------------------
------------------
66| 3.17k| fclose(file);
67| |
68| 3.17k| file = tmpfile();
69| 3.17k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.17k| do { \
| | 925| 3.17k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.17k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.17k]
| | ------------------
------------------
70| 3.17k| CHECK_ERR(igraph_write_graph_gml(&g, file, IGRAPH_WRITE_GML_DEFAULT_SW, NULL, "no one"));
------------------
| | 29| 3.17k| do { \
| | 30| 3.17k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.17k| expr; \
| | 32| 3.17k| igraph_set_error_handler(handler); \
| | 33| 3.17k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.17k]
| | ------------------
------------------
71| 3.17k| rewind(file);
72| 3.17k| CHECK_ERR(igraph_read_graph_gml(&g2, file));
------------------
| | 29| 3.17k| do { \
| | 30| 3.17k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.17k| expr; \
| | 32| 3.17k| igraph_set_error_handler(handler); \
| | 33| 3.17k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.17k]
| | ------------------
------------------
73| 3.17k| igraph_destroy(&g2);
74| 3.17k| fclose(file);
75| |
76| | // Reading Pajek files back is disabled because of
77| | // https://github.com/igraph/igraph/issues/2560
78| 3.17k| file = tmpfile();
79| 3.17k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.17k| do { \
| | 925| 3.17k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.17k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.17k]
| | ------------------
------------------
80| 3.17k| CHECK_ERR(igraph_write_graph_pajek(&g, file));
------------------
| | 29| 3.17k| do { \
| | 30| 3.17k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.17k| expr; \
| | 32| 3.17k| igraph_set_error_handler(handler); \
| | 33| 3.17k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.17k]
| | ------------------
------------------
81| | /*
82| | rewind(file);
83| | CHECK_ERR(igraph_read_graph_pajek(&g2, file));
84| | igraph_destroy(&g2);
85| | */
86| 3.17k| fclose(file);
87| |
88| 3.17k| file = tmpfile();
89| 3.17k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.17k| do { \
| | 925| 3.17k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.17k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.17k]
| | ------------------
------------------
90| | // Do not check error when writing GraphML because string attributes
91| | // may contain forbidden control characters.
92| 3.17k| if (igraph_write_graph_graphml(&g, file, false) == IGRAPH_SUCCESS) {
------------------
| Branch (92:13): [True: 3.17k, False: 0]
------------------
93| 3.17k| rewind(file);
94| | // Do not check error when reading because strings may not be
95| | // in a valid encoding, which confuses libxml2.
96| 3.17k| if (igraph_read_graph_graphml(&g2, file, 0) == IGRAPH_SUCCESS) {
------------------
| Branch (96:17): [True: 3.13k, False: 40]
------------------
97| 3.13k| igraph_destroy(&g2);
98| 3.13k| }
99| 3.17k| }
100| 3.17k| fclose(file);
101| |
102| 3.17k| file = tmpfile();
103| 3.17k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.17k| do { \
| | 925| 3.17k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.17k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.17k]
| | ------------------
------------------
104| | // Do not check error when writing LGL because not all possible
105| | // vertex names are supported by this format.
106| 3.17k| if (igraph_write_graph_lgl(&g, file, "label", "weight", false) == IGRAPH_SUCCESS) {
------------------
| Branch (106:13): [True: 3.02k, False: 151]
------------------
107| 3.02k| rewind(file);
108| 3.02k| CHECK_ERR(igraph_read_graph_lgl(&g2, file, true, IGRAPH_ADD_WEIGHTS_IF_PRESENT, true));
------------------
| | 29| 3.02k| do { \
| | 30| 3.02k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.02k| expr; \
| | 32| 3.02k| igraph_set_error_handler(handler); \
| | 33| 3.02k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.02k]
| | ------------------
------------------
109| 3.02k| igraph_destroy(&g2);
110| 3.02k| }
111| 3.17k| fclose(file);
112| |
113| 3.17k| file = tmpfile();
114| 3.17k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.17k| do { \
| | 925| 3.17k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.17k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.17k]
| | ------------------
------------------
115| | // Do not check error when writing NCOL because not all possible
116| | // vertex names are supported by this format.
117| 3.17k| if (igraph_write_graph_ncol(&g, file, "label", "weight") == IGRAPH_SUCCESS) {
------------------
| Branch (117:13): [True: 3.08k, False: 97]
------------------
118| 3.08k| rewind(file);
119| 3.08k| CHECK_ERR(igraph_read_graph_ncol(&g2, file, NULL, true, IGRAPH_ADD_WEIGHTS_IF_PRESENT, true));
------------------
| | 29| 3.08k| do { \
| | 30| 3.08k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.08k| expr; \
| | 32| 3.08k| igraph_set_error_handler(handler); \
| | 33| 3.08k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.08k]
| | ------------------
------------------
120| 3.08k| igraph_destroy(&g2);
121| 3.08k| }
122| 3.17k| fclose(file);
123| |
124| | // Clean up
125| 3.17k| igraph_destroy(&g);
126| 3.17k| }
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.1k| fclose(ifile);
132| |
133| 19.1k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY);
------------------
| | 924| 19.1k| do { \
| | 925| 19.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 19.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 19.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 19.1k]
| | ------------------
------------------
134| |
135| 19.1k| return 0;
136| 19.1k|}
igraph_error:
210| 17.7k| igraph_error_t igraph_errno) {
211| |
212| 17.7k| if (igraph_i_error_handler) {
------------------
| Branch (212:9): [True: 17.7k, False: 0]
------------------
213| 17.7k| igraph_i_error_handler(reason, file, line, igraph_errno);
214| 17.7k|#ifndef USING_R
215| 17.7k| } else {
216| 0| igraph_error_handler_abort(reason, file, line, igraph_errno);
217| 0|#endif
218| 0| }
219| 17.7k| return igraph_errno;
220| 17.7k|}
igraph_errorf:
240| 550| igraph_error_t igraph_errno, ...) {
241| 550| va_list ap;
242| 550| va_start(ap, igraph_errno);
243| 550| vsnprintf(igraph_i_errormsg_buffer,
244| 550| sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap);
245| | va_end(ap);
246| 550| return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno);
247| 550|}
igraph_error_handler_ignore:
266| 17.7k| int line, igraph_error_t igraph_errno) {
267| 17.7k| IGRAPH_UNUSED(reason);
------------------
| | 30| 17.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
268| 17.7k| IGRAPH_UNUSED(file);
------------------
| | 30| 17.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
269| 17.7k| IGRAPH_UNUSED(line);
------------------
| | 30| 17.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
270| 17.7k| IGRAPH_UNUSED(igraph_errno);
------------------
| | 30| 17.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
271| |
272| 17.7k| IGRAPH_FINALLY_FREE();
273| 17.7k|}
igraph_set_error_handler:
298| 56.7k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) {
299| 56.7k| igraph_error_handler_t *previous_handler = igraph_i_error_handler;
300| 56.7k| igraph_i_error_handler = new_handler;
301| 56.7k| return previous_handler;
302| 56.7k|}
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.72M|void IGRAPH_FINALLY_CLEAN(int minus) {
339| 8.72M| igraph_i_finally_stack_size -= minus;
340| 8.72M| if (igraph_i_finally_stack_size < 0) {
------------------
| Branch (340:9): [True: 0, False: 8.72M]
------------------
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.72M|}
IGRAPH_FINALLY_FREE:
348| 17.7k|void IGRAPH_FINALLY_FREE(void) {
349| 51.4k| for (; igraph_i_finally_stack_size > 0; igraph_i_finally_stack_size--) {
------------------
| Branch (349:12): [True: 34.8k, False: 16.5k]
------------------
350| 34.8k| int p = igraph_i_finally_stack_size - 1;
351| | /* Call destructors only up to the current level */
352| 34.8k| if (igraph_i_finally_stack[p].level < igraph_i_finally_stack_level) {
------------------
| Branch (352:13): [True: 1.15k, False: 33.6k]
------------------
353| 1.15k| break;
354| 1.15k| }
355| 33.6k| igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr);
356| 33.6k| }
357| 17.7k|}
IGRAPH_FINALLY_STACK_SIZE:
359| 19.1k|int IGRAPH_FINALLY_STACK_SIZE(void) {
360| 19.1k| return igraph_i_finally_stack_size;
361| 19.1k|}
IGRAPH_FINALLY_ENTER:
377| 2.59M|void IGRAPH_FINALLY_ENTER(void) {
378| 2.59M| int no = igraph_i_finally_stack_size;
379| | /* Level indices must always be in increasing order in the finally stack */
380| 2.59M| if (no > 0 && igraph_i_finally_stack[no-1].level > igraph_i_finally_stack_level) {
------------------
| Branch (380:9): [True: 2.59M, False: 0]
| Branch (380:19): [True: 0, False: 2.59M]
------------------
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.59M| igraph_i_finally_stack_level++;
386| 2.59M|}
IGRAPH_FINALLY_EXIT:
399| 2.59M|void IGRAPH_FINALLY_EXIT(void) {
400| 2.59M| igraph_i_finally_stack_level--;
401| 2.59M| if (igraph_i_finally_stack_level < 0) {
------------------
| Branch (401:9): [True: 0, False: 2.59M]
------------------
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.59M|}
igraph_warning_handler_ignore:
424| 50.5k|void igraph_warning_handler_ignore(const char *reason, const char *file, int line) {
425| 50.5k| IGRAPH_UNUSED(reason);
------------------
| | 30| 50.5k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
426| 50.5k| IGRAPH_UNUSED(file);
------------------
| | 30| 50.5k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
427| 50.5k| IGRAPH_UNUSED(line);
------------------
| | 30| 50.5k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
428| 50.5k|}
igraph_warning:
463| 50.5k|void igraph_warning(const char *reason, const char *file, int line) {
464| |
465| 50.5k| if (igraph_i_warning_handler) {
------------------
| Branch (465:9): [True: 50.5k, False: 0]
------------------
466| 50.5k| igraph_i_warning_handler(reason, file, line);
467| 50.5k|#ifndef USING_R
468| 50.5k| } else {
469| 0| igraph_warning_handler_print(reason, file, line);
470| 0|#endif
471| 0| }
472| 50.5k|}
igraph_warningf:
492| 36.7k|void igraph_warningf(const char *reason, const char *file, int line, ...) {
493| 36.7k| va_list ap;
494| 36.7k| va_start(ap, line);
495| 36.7k| vsnprintf(igraph_i_warningmsg_buffer,
496| 36.7k| sizeof(igraph_i_warningmsg_buffer) / sizeof(char), reason, ap);
497| | va_end(ap);
498| 36.7k| igraph_warning(igraph_i_warningmsg_buffer, file, line);
499| 36.7k|}
igraph_set_warning_handler:
514| 19.1k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) {
515| 19.1k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler;
516| 19.1k| igraph_i_warning_handler = new_handler;
517| 19.1k| return previous_handler;
518| 19.1k|}
igraph_free:
62| 177k|void igraph_free(void *ptr) {
63| | IGRAPH_FREE(ptr);
------------------
| | 36| 177k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
64| 177k|}
igraph_real_fprintf_precise:
117| 373k|int igraph_real_fprintf_precise(FILE *file, igraph_real_t val) {
118| 373k| if (isfinite(val)) {
------------------
| Branch (118:9): [True: 9.30k, False: 364k]
------------------
119| 9.30k| return fprintf(file, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
------------------
| | 54| 9.30k| #define IGRAPH_REAL_PRINTF_PRECISE_FORMAT "%." IGRAPH_I_STRINGIFY(DBL_DIG) "g"
------------------
120| 364k| } else if (isnan(val)) {
------------------
| Branch (120:16): [True: 364k, False: 0]
------------------
121| 364k| return fprintf(file, "NaN");
122| 364k| } 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| 95.9k|int igraph_real_snprintf_precise(char *str, size_t size, igraph_real_t val) {
139| 95.9k| if (isfinite(val)) {
------------------
| Branch (139:9): [True: 1.42k, False: 94.5k]
------------------
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| 94.5k| } else if (isnan(val)) {
------------------
| Branch (141:16): [True: 94.5k, False: 0]
------------------
142| 94.5k| return snprintf(str, size, "NaN");
143| 94.5k| } 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| 270k|igraph_error_t igraph_strvector_init(igraph_strvector_t *sv, igraph_int_t size) {
72| |
73| 270k| sv->stor_begin = IGRAPH_CALLOC(size, const char *);
------------------
| | 33| 270k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 541k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 270k, False: 0]
| | | | | Branch (31:24): [True: 270k, False: 0]
| | | | | Branch (31:66): [True: 35.9k, False: 234k]
| | | | ------------------
| | ------------------
------------------
74| 270k| IGRAPH_CHECK_OOM(sv->stor_begin, "Cannot initialize string vector.");
------------------
| | 709| 270k| do { \
| | 710| 270k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 270k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 270k]
| | | | ------------------
| | ------------------
| | 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| 270k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 270k]
| | ------------------
------------------
75| |
76| 270k| sv->stor_end = sv->stor_begin + size;
77| 270k| sv->end = sv->stor_end;
78| |
79| 270k| return IGRAPH_SUCCESS;
80| 270k|}
igraph_strvector_destroy:
95| 270k|void igraph_strvector_destroy(igraph_strvector_t *sv) {
96| 270k| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 270k| do { \
| | 925| 270k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 270k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 270k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 270k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 270k]
| | ------------------
------------------
97| 270k| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 270k| do { \
| | 925| 270k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 270k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 270k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 270k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 270k]
| | ------------------
------------------
98| 3.23M| for (const char **ptr = sv->stor_begin; ptr < sv->end; ptr++) {
------------------
| Branch (98:45): [True: 2.95M, False: 270k]
------------------
99| 2.95M| IGRAPH_FREE(*ptr);
------------------
| | 36| 2.95M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
100| 2.95M| }
101| | IGRAPH_FREE(sv->stor_begin);
------------------
| | 36| 270k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
102| 270k|}
igraph_strvector_get:
117| 21.0M|const char *igraph_strvector_get(const igraph_strvector_t *sv, igraph_int_t idx) {
118| 21.0M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 21.0M| do { \
| | 925| 21.0M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 21.0M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 21.0M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 21.0M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 21.0M]
| | ------------------
------------------
119| 21.0M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 21.0M| do { \
| | 925| 21.0M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 21.0M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 21.0M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 21.0M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 21.0M]
| | ------------------
------------------
120| 21.0M| return sv->stor_begin[idx] ? sv->stor_begin[idx] : "";
------------------
| Branch (120:12): [True: 20.6M, False: 382k]
------------------
121| 21.0M|}
igraph_strvector_set:
141| 2.26M| const char *value) {
142| 2.26M| return igraph_strvector_set_len(sv, idx, value, strlen(value));
143| 2.26M|}
igraph_strvector_set_len:
163| 2.26M| const char *value, size_t len) {
164| 2.26M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 2.26M| do { \
| | 925| 2.26M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.26M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.26M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.26M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.26M]
| | ------------------
------------------
165| 2.26M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 2.26M| do { \
| | 925| 2.26M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.26M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.26M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.26M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.26M]
| | ------------------
------------------
166| |
167| 2.26M| if (sv->stor_begin[idx] == NULL) {
------------------
| Branch (167:9): [True: 2.25M, False: 16.8k]
------------------
168| 2.25M| sv->stor_begin[idx] = strndup(value, len);
169| 2.25M| IGRAPH_CHECK_OOM(sv->stor_begin[idx], "Cannot reserve space for new item in string vector.");
------------------
| | 709| 2.25M| do { \
| | 710| 2.25M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 2.25M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.25M]
| | | | ------------------
| | ------------------
| | 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.25M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 2.25M]
| | ------------------
------------------
170| 2.25M| } else {
171| 16.8k| char *tmp = IGRAPH_REALLOC(sv->stor_begin[idx], len + 1, char);
------------------
| | 35| 16.8k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 33.7k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 16.8k, False: 0]
| | | | | Branch (31:24): [True: 16.8k, False: 0]
| | | | | Branch (31:66): [True: 16.8k, False: 0]
| | | | ------------------
| | ------------------
------------------
172| 16.8k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new item in string vector.");
------------------
| | 709| 16.8k| do { \
| | 710| 16.8k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 16.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.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| 16.8k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 16.8k]
| | ------------------
------------------
173| |
174| 16.8k| memcpy(tmp, value, len * sizeof(char));
175| 16.8k| tmp[len] = '\0';
176| 16.8k| sv->stor_begin[idx] = tmp;
177| 16.8k| }
178| |
179| 2.26M| return IGRAPH_SUCCESS;
180| 2.26M|}
igraph_strvector_append:
300| 33.4k| const igraph_strvector_t *from) {
301| 33.4k| const igraph_int_t to_size = igraph_strvector_size(to);
302| 33.4k| const igraph_int_t from_size = igraph_strvector_size(from);
303| 33.4k| const igraph_int_t to_capacity = igraph_strvector_capacity(to);
304| 33.4k| igraph_int_t new_to_size;
305| 33.4k| igraph_bool_t error = false;
306| 33.4k| const char *tmp;
307| |
308| 33.4k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 33.4k| do { \
| | 48| 33.4k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 33.4k| igraph_int_t _safe_sum; \
| | 50| 33.4k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 33.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| 33.4k| *(res) = _safe_sum; \
| | 54| 33.4k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 33.4k]
| | ------------------
------------------
309| |
310| 33.4k| if (to_capacity < new_to_size) {
------------------
| Branch (310:9): [True: 26.1k, False: 7.27k]
------------------
311| 26.1k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 26.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| 26.1k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (311:40): [True: 26.1k, False: 0]
------------------
312| 26.1k| if (new_to_capacity < new_to_size) {
------------------
| Branch (312:13): [True: 26.1k, False: 5]
------------------
313| 26.1k| new_to_capacity = new_to_size;
314| 26.1k| }
315| 26.1k| IGRAPH_CHECK(igraph_strvector_reserve(to, new_to_capacity));
------------------
| | 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]
| | ------------------
------------------
316| 26.1k| }
317| |
318| 1.54M| for (igraph_int_t i = 0; i < from_size; i++) {
------------------
| Branch (318:30): [True: 1.50M, False: 33.4k]
------------------
319| 1.50M| if (from->stor_begin[i] == NULL || from->stor_begin[i][0] == '\0') {
------------------
| Branch (319:13): [True: 158k, False: 1.34M]
| Branch (319:44): [True: 264k, False: 1.08M]
------------------
320| | /* Represent empty strings as NULL. */
321| 422k| tmp = NULL;
322| 1.08M| } else {
323| 1.08M| tmp = strdup(from->stor_begin[i]);
324| 1.08M| if (tmp == NULL) {
------------------
| Branch (324:17): [True: 0, False: 1.08M]
------------------
325| 0| error = true;
326| 0| break;
327| 0| }
328| 1.08M| }
329| 1.50M| *(to->end) = tmp;
330| 1.50M| to->end++;
331| 1.50M| }
332| |
333| 33.4k| if (error) {
------------------
| Branch (333:9): [True: 0, False: 33.4k]
------------------
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| 33.4k| return IGRAPH_SUCCESS;
339| 33.4k|}
igraph_strvector_clear:
393| 1.15M|void igraph_strvector_clear(igraph_strvector_t *sv) {
394| 1.15M| igraph_int_t n = igraph_strvector_size(sv);
395| |
396| 2.32M| for (igraph_int_t i = 0; i < n; i++) {
------------------
| Branch (396:30): [True: 1.16M, False: 1.15M]
------------------
397| | IGRAPH_FREE(sv->stor_begin[i]);
------------------
| | 36| 1.16M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
398| 1.16M| }
399| 1.15M| sv->end = sv->stor_begin;
400| 1.15M|}
igraph_strvector_resize:
419| 4.11M|igraph_error_t igraph_strvector_resize(igraph_strvector_t *sv, igraph_int_t newsize) {
420| 4.11M| igraph_int_t toadd = newsize - igraph_strvector_size(sv);
421| 4.11M| igraph_int_t oldsize = igraph_strvector_size(sv);
422| |
423| 4.11M| if (newsize < oldsize) {
------------------
| Branch (423:9): [True: 2.40M, False: 1.70M]
------------------
424| 4.80M| for (igraph_int_t i = newsize; i < oldsize; i++) {
------------------
| Branch (424:40): [True: 2.40M, False: 2.40M]
------------------
425| 2.40M| IGRAPH_FREE(sv->stor_begin[i]);
------------------
| | 36| 2.40M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
426| 2.40M| }
427| 2.40M| sv->end = sv->stor_begin + newsize;
428| 2.40M| } else if (newsize > oldsize) {
------------------
| Branch (428:16): [True: 1.68M, False: 19.8k]
------------------
429| 1.68M| IGRAPH_CHECK(igraph_strvector_reserve(sv, newsize));
------------------
| | 656| 1.68M| do { \
| | 657| 1.68M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.68M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.68M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.68M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.68M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.68M]
| | ------------------
------------------
430| 1.68M| memset(sv->stor_begin + oldsize, 0, toadd * sizeof(const char *));
431| 1.68M| sv->end = sv->stor_begin + newsize;
432| 1.68M| }
433| |
434| 4.11M| return IGRAPH_SUCCESS;
435| 4.11M|}
igraph_strvector_capacity:
448| 1.86M|igraph_int_t igraph_strvector_capacity(const igraph_strvector_t *sv) {
449| 1.86M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 1.86M| do { \
| | 925| 1.86M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.86M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.86M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.86M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.86M]
| | ------------------
------------------
450| 1.86M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 1.86M| do { \
| | 925| 1.86M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.86M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.86M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.86M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.86M]
| | ------------------
------------------
451| 1.86M| return sv->stor_end - sv->stor_begin;
452| 1.86M|}
igraph_strvector_reserve:
481| 1.83M|igraph_error_t igraph_strvector_reserve(igraph_strvector_t *sv, igraph_int_t capacity) {
482| 1.83M| igraph_int_t current_capacity = igraph_strvector_capacity(sv);
483| |
484| 1.83M| if (capacity <= current_capacity) {
------------------
| Branch (484:9): [True: 1.13M, False: 695k]
------------------
485| 1.13M| return IGRAPH_SUCCESS;
486| 1.13M| }
487| |
488| 695k| const char **tmp = IGRAPH_REALLOC(sv->stor_begin, capacity, const char *);
------------------
| | 35| 695k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 1.39M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 695k, False: 0]
| | | | | Branch (31:24): [True: 695k, False: 0]
| | | | | Branch (31:66): [True: 695k, False: 0]
| | | | ------------------
| | ------------------
------------------
489| 695k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new items in string vector.");
------------------
| | 709| 695k| do { \
| | 710| 695k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 695k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 695k]
| | | | ------------------
| | ------------------
| | 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| 695k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 695k]
| | ------------------
------------------
490| |
491| 695k| sv->end = tmp + (sv->end - sv->stor_begin);
492| 695k| sv->stor_begin = tmp;
493| 695k| sv->stor_end = sv->stor_begin + capacity;
494| |
495| 695k| return IGRAPH_SUCCESS;
496| 695k|}
igraph_strvector_size:
538| 16.3M|igraph_int_t igraph_strvector_size(const igraph_strvector_t *sv) {
539| 16.3M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 16.3M| do { \
| | 925| 16.3M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.3M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.3M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.3M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.3M]
| | ------------------
------------------
540| 16.3M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 16.3M| do { \
| | 925| 16.3M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.3M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.3M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.3M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.3M]
| | ------------------
------------------
541| 16.3M| return sv->end - sv->stor_begin;
542| 16.3M|}
igraph_strvector_push_back:
580| 2.66M|igraph_error_t igraph_strvector_push_back(igraph_strvector_t *sv, const char *value) {
581| 2.66M| IGRAPH_CHECK(strvector_expand_if_full(sv));
------------------
| | 656| 2.66M| do { \
| | 657| 2.66M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.66M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.66M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.66M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.66M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.66M]
| | ------------------
------------------
582| 2.66M| const char *tmp = strdup(value);
583| 2.66M| IGRAPH_CHECK_OOM(tmp, "Cannot push new string to string vector.");
------------------
| | 709| 2.66M| do { \
| | 710| 2.66M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 2.66M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.66M]
| | | | ------------------
| | ------------------
| | 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.66M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 2.66M]
| | ------------------
------------------
584| 2.66M| *sv->end = tmp;
585| 2.66M| sv->end++;
586| |
587| 2.66M| return IGRAPH_SUCCESS;
588| 2.66M|}
igraph_strvector_update:
698| 11.7k|) {
699| 11.7k| igraph_strvector_clear(to);
700| 11.7k| IGRAPH_CHECK(igraph_strvector_append(to, from));
------------------
| | 656| 11.7k| do { \
| | 657| 11.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.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| 11.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.7k]
| | ------------------
------------------
701| 11.7k| return IGRAPH_SUCCESS;
702| 11.7k|}
strvector.c:strvector_expand_if_full:
548| 2.66M|static igraph_error_t strvector_expand_if_full(igraph_strvector_t *sv) {
549| 2.66M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 2.66M| do { \
| | 925| 2.66M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.66M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.66M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.66M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.66M]
| | ------------------
------------------
550| 2.66M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 2.66M| do { \
| | 925| 2.66M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.66M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.66M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.66M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.66M]
| | ------------------
------------------
551| |
552| 2.66M| if (sv->stor_end == sv->end) {
------------------
| Branch (552:9): [True: 122k, False: 2.54M]
------------------
553| 122k| igraph_int_t old_size = igraph_strvector_size(sv);
554| 122k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 122k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 122k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (554:33): [True: 122k, False: 0]
------------------
555| 122k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 122k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (555:13): [True: 0, False: 122k]
------------------
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| 122k| if (new_size == 0) {
------------------
| Branch (558:13): [True: 34.9k, False: 87.6k]
------------------
559| 34.9k| new_size = 1;
560| 34.9k| }
561| 122k| IGRAPH_CHECK(igraph_strvector_reserve(sv, new_size));
------------------
| | 656| 122k| do { \
| | 657| 122k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 122k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 122k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 122k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 122k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 122k]
| | ------------------
------------------
562| 122k| }
563| |
564| 2.66M| return IGRAPH_SUCCESS;
565| 2.66M|}
igraph_trie_init:
61| 108k|igraph_error_t igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) {
62| 108k| t->maxvalue = -1;
63| 108k| t->storekeys = storekeys;
64| 108k| IGRAPH_CHECK(igraph_i_trie_init_node(&t->node));
------------------
| | 656| 108k| do { \
| | 657| 108k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 108k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 108k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 108k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 108k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 108k]
| | ------------------
------------------
65| 108k| IGRAPH_FINALLY(igraph_i_trie_destroy_node, &t->node);
------------------
| | 603| 108k| do { \
| | 604| 108k| /* the following branch makes the compiler check the compatibility of \
| | 605| 108k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 108k| * incorrect destructor function with the pointer */ \
| | 607| 108k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 108k]
| | ------------------
| | 608| 108k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 108k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 108k]
| | ------------------
------------------
66| 108k| if (storekeys) {
------------------
| Branch (66:9): [True: 28.4k, False: 79.6k]
------------------
67| 28.4k| IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0));
------------------
| | 656| 28.4k| do { \
| | 657| 28.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 28.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 28.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.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| 28.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 28.4k]
| | ------------------
------------------
68| 28.4k| }
69| |
70| 108k| IGRAPH_FINALLY_CLEAN(1);
71| 108k| return IGRAPH_SUCCESS;
72| 108k|}
igraph_trie_destroy:
102| 108k|void igraph_trie_destroy(igraph_trie_t *t) {
103| 108k| if (t->storekeys) {
------------------
| Branch (103:9): [True: 28.4k, False: 79.6k]
------------------
104| 28.4k| igraph_strvector_destroy(&t->keys);
105| 28.4k| }
106| 108k| igraph_i_trie_destroy_node(&t->node);
107| 108k|}
igraph_trie_get:
298| 3.41M|igraph_error_t igraph_trie_get(igraph_trie_t *t, const char *key, igraph_int_t *id) {
299| 3.41M| assert(key != NULL);
------------------
| Branch (299:5): [True: 0, False: 3.41M]
| Branch (299:5): [True: 3.41M, False: 0]
------------------
300| |
301| 3.41M| if (*key == '\0') {
------------------
| Branch (301:9): [True: 4, False: 3.41M]
------------------
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.41M| if (!t->storekeys) {
------------------
| Branch (305:9): [True: 891k, False: 2.52M]
------------------
306| 891k| IGRAPH_CHECK(igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id));
------------------
| | 656| 891k| do { \
| | 657| 891k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 891k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 891k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 891k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 891k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 891k]
| | ------------------
------------------
307| 891k| if (*id > t->maxvalue) {
------------------
| Branch (307:13): [True: 53.3k, False: 837k]
------------------
308| 53.3k| t->maxvalue = *id;
309| 53.3k| }
310| 2.52M| } else {
311| 2.52M| igraph_error_t ret;
312| |
313| 2.52M| IGRAPH_FINALLY_ENTER();
314| | /* Add it to the string vector first, we can undo this later */
315| 2.52M| ret = igraph_strvector_push_back(&t->keys, key);
316| 2.52M| if (ret != IGRAPH_SUCCESS) {
------------------
| Branch (316:13): [True: 0, False: 2.52M]
------------------
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.52M| ret = igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id);
321| 2.52M| if (ret != IGRAPH_SUCCESS) {
------------------
| Branch (321:13): [True: 0, False: 2.52M]
------------------
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.52M| if (*id > t->maxvalue) {
------------------
| Branch (328:13): [True: 116k, False: 2.40M]
------------------
329| 116k| t->maxvalue = *id;
330| 2.40M| } else {
331| 2.40M| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */
332| 2.40M| }
333| 2.52M| IGRAPH_FINALLY_EXIT();
334| 2.52M| }
335| |
336| 3.41M| return IGRAPH_SUCCESS;
337| 3.41M|}
igraph_trie_get_len:
357| 1.06M| igraph_int_t *id) {
358| |
359| 1.06M| char *tmp = strndup(key, length);
360| 1.06M| IGRAPH_CHECK_OOM(tmp, "Cannot get from trie.");
------------------
| | 709| 1.06M| do { \
| | 710| 1.06M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.06M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.06M]
| | | | ------------------
| | ------------------
| | 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.06M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.06M]
| | ------------------
------------------
361| 1.06M| IGRAPH_FINALLY(igraph_free, tmp);
------------------
| | 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]
| | ------------------
------------------
362| 1.06M| IGRAPH_CHECK(igraph_trie_get(t, tmp, id));
------------------
| | 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]
| | ------------------
------------------
363| 1.06M| IGRAPH_FREE(tmp);
------------------
| | 36| 1.06M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
364| 1.06M| IGRAPH_FINALLY_CLEAN(1);
365| |
366| 1.06M| return IGRAPH_SUCCESS;
367| 1.06M|}
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| 457k|igraph_int_t igraph_trie_size(igraph_trie_t *t) {
414| 457k| return t->maxvalue + 1;
415| 457k|}
igraph_i_trie_borrow_keys:
432| 9.23k|const igraph_strvector_t* igraph_i_trie_borrow_keys(igraph_trie_t *t) {
433| 9.23k| return &t->keys;
434| 9.23k|}
trie.c:igraph_i_trie_init_node:
41| 108k|static igraph_error_t igraph_i_trie_init_node(igraph_trie_node_t *t) {
42| 108k| IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0);
------------------
| | 62| 108k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 108k| do { \
| | | | 657| 108k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 108k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 108k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 108k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 108k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 108k]
| | | | ------------------
| | ------------------
| | 63| 108k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 108k| do { \
| | | | 604| 108k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 108k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 108k| * incorrect destructor function with the pointer */ \
| | | | 607| 108k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 108k]
| | | | ------------------
| | | | 608| 108k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 108k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 108k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 108k]
| | ------------------
------------------
43| 108k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0);
------------------
| | 46| 108k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 108k| do { \
| | | | 657| 108k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 108k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 108k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 108k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 108k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 108k]
| | | | ------------------
| | ------------------
| | 47| 108k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 108k| do { \
| | | | 604| 108k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 108k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 108k| * incorrect destructor function with the pointer */ \
| | | | 607| 108k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 108k]
| | | | ------------------
| | | | 608| 108k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 108k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 108k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 108k]
| | ------------------
------------------
44| 108k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->values, 0);
------------------
| | 119| 108k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 108k| do { \
| | | | 657| 108k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 108k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 108k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 108k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 108k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 108k]
| | | | ------------------
| | ------------------
| | 120| 108k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 108k| do { \
| | | | 604| 108k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 108k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 108k| * incorrect destructor function with the pointer */ \
| | | | 607| 108k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 108k]
| | | | ------------------
| | | | 608| 108k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 108k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 108k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 108k]
| | ------------------
------------------
45| 108k| IGRAPH_FINALLY_CLEAN(3);
46| 108k| return IGRAPH_SUCCESS;
47| 108k|}
trie.c:igraph_i_trie_destroy_node:
91| 108k|static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) {
92| | igraph_i_trie_destroy_node_helper(t, false);
93| 108k|}
trie.c:igraph_i_trie_destroy_node_helper:
74| 133k|static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) {
75| 133k| igraph_strvector_destroy(&t->strs);
76| 133k| igraph_int_t children_size = igraph_vector_ptr_size(&t->children);
77| 316k| for (igraph_int_t i = 0; i < children_size; i++) {
------------------
| Branch (77:30): [True: 183k, False: 133k]
------------------
78| 183k| igraph_trie_node_t *child = VECTOR(t->children)[i];
------------------
| | 60| 183k|#define VECTOR(v) ((v).stor_begin)
------------------
79| 183k| if (child != NULL) {
------------------
| Branch (79:13): [True: 25.0k, False: 158k]
------------------
80| 25.0k| igraph_i_trie_destroy_node_helper(child, true);
81| 25.0k| }
82| 183k| }
83| 133k| igraph_vector_ptr_destroy(&t->children);
84| 133k| igraph_vector_int_destroy(&t->values);
85| 133k| if (sfree) {
------------------
| Branch (85:9): [True: 25.0k, False: 108k]
------------------
86| | IGRAPH_FREE(t);
------------------
| | 36| 25.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
87| 25.0k| }
88| 133k|}
trie.c:igraph_i_trie_get_node:
129| 6.76M|) {
130| 6.76M| assert(key != NULL);
------------------
| Branch (130:5): [True: 0, False: 6.76M]
| Branch (130:5): [True: 6.76M, False: 0]
------------------
131| |
132| | /* If newvalue is negative, we don't add the node if nonexistent, only check
133| | * for its existence */
134| 6.76M| igraph_bool_t add = (newvalue >= 0);
135| |
136| 6.76M| igraph_int_t strs_size = igraph_strvector_size(&t->strs);
137| 17.2M| for (igraph_int_t i = 0; i < strs_size; i++) {
------------------
| Branch (137:30): [True: 17.0M, False: 156k]
------------------
138| 17.0M| size_t diff;
139| 17.0M| const char *str = igraph_strvector_get(&t->strs, i);
140| 17.0M| diff = igraph_i_strdiff(str, key);
141| |
142| 17.0M| if (diff == 0) {
------------------
| Branch (142:13): [True: 10.4M, False: 6.60M]
------------------
143| |
144| | /* ------------------------------------ */
145| | /* No match, next */
146| |
147| 10.4M| } else if (str[diff] == '\0' && key[diff] == '\0') {
------------------
| Branch (147:20): [True: 6.58M, False: 18.2k]
| Branch (147:41): [True: 4.35M, False: 2.23M]
------------------
148| |
149| | /* ------------------------------------ */
150| | /* They are exactly the same */
151| 4.35M| if (VECTOR(t->values)[i] != -1) {
------------------
| | 60| 4.35M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (151:17): [True: 4.35M, False: 732]
------------------
152| 4.35M| *id = VECTOR(t->values)[i];
------------------
| | 60| 4.35M|#define VECTOR(v) ((v).stor_begin)
------------------
153| 4.35M| return IGRAPH_SUCCESS;
154| 4.35M| } else {
155| 732| VECTOR(t->values)[i] = newvalue;
------------------
| | 60| 732|#define VECTOR(v) ((v).stor_begin)
------------------
156| 732| *id = newvalue;
157| 732| return IGRAPH_SUCCESS;
158| 732| }
159| |
160| 4.35M| } else if (str[diff] == '\0') {
------------------
| Branch (160:20): [True: 2.23M, False: 18.2k]
------------------
161| |
162| | /* ------------------------------------ */
163| | /* str is prefix of key, follow its link if there is one */
164| 2.23M| igraph_trie_node_t *node = VECTOR(t->children)[i];
------------------
| | 60| 2.23M|#define VECTOR(v) ((v).stor_begin)
------------------
165| 2.23M| if (node != NULL) {
------------------
| Branch (165:17): [True: 2.22M, False: 9.57k]
------------------
166| 2.22M| return igraph_i_trie_get_node(node, key + diff, newvalue, id);
167| 2.22M| } else if (add) {
------------------
| Branch (167:24): [True: 9.27k, False: 304]
------------------
168| 9.27k| igraph_trie_node_t *new_node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 9.27k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 18.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: 9.27k, Folded]
| | | | ------------------
| | ------------------
------------------
169| 9.27k| IGRAPH_CHECK_OOM(new_node, "Cannot add to trie.");
------------------
| | 709| 9.27k| do { \
| | 710| 9.27k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 9.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.27k]
| | | | ------------------
| | ------------------
| | 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.27k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 9.27k]
| | ------------------
------------------
170| 9.27k| IGRAPH_FINALLY(igraph_free, new_node);
------------------
| | 603| 9.27k| do { \
| | 604| 9.27k| /* the following branch makes the compiler check the compatibility of \
| | 605| 9.27k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 9.27k| * incorrect destructor function with the pointer */ \
| | 607| 9.27k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 9.27k]
| | ------------------
| | 608| 9.27k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 9.27k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 9.27k]
| | ------------------
------------------
171| |
172| 9.27k| IGRAPH_STRVECTOR_INIT_FINALLY(&new_node->strs, 1);
------------------
| | 62| 9.27k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 9.27k| do { \
| | | | 657| 9.27k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.27k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.27k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.27k]
| | | | ------------------
| | ------------------
| | 63| 9.27k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 9.27k| do { \
| | | | 604| 9.27k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.27k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.27k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.27k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.27k]
| | | | ------------------
| | | | 608| 9.27k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.27k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.27k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 9.27k]
| | ------------------
------------------
173| 9.27k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&new_node->children, 1);
------------------
| | 46| 9.27k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 9.27k| do { \
| | | | 657| 9.27k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.27k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.27k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.27k]
| | | | ------------------
| | ------------------
| | 47| 9.27k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 9.27k| do { \
| | | | 604| 9.27k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.27k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.27k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.27k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.27k]
| | | | ------------------
| | | | 608| 9.27k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.27k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.27k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 9.27k]
| | ------------------
------------------
174| 9.27k| IGRAPH_VECTOR_INT_INIT_FINALLY(&new_node->values, 1);
------------------
| | 119| 9.27k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 9.27k| do { \
| | | | 657| 9.27k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.27k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.27k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.27k]
| | | | ------------------
| | ------------------
| | 120| 9.27k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 9.27k| do { \
| | | | 604| 9.27k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.27k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.27k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.27k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.27k]
| | | | ------------------
| | | | 608| 9.27k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.27k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.27k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 9.27k]
| | ------------------
------------------
175| 9.27k| IGRAPH_CHECK(igraph_strvector_set(&new_node->strs, 0, key + diff));
------------------
| | 656| 9.27k| do { \
| | 657| 9.27k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 9.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 9.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.27k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.27k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 9.27k]
| | ------------------
------------------
176| 9.27k| IGRAPH_FINALLY_CLEAN(4);
177| |
178| 9.27k| VECTOR(new_node->children)[0] = 0;
------------------
| | 60| 9.27k|#define VECTOR(v) ((v).stor_begin)
------------------
179| 9.27k| VECTOR(new_node->values)[0] = newvalue;
------------------
| | 60| 9.27k|#define VECTOR(v) ((v).stor_begin)
------------------
180| |
181| 9.27k| VECTOR(t->children)[i] = new_node;
------------------
| | 60| 9.27k|#define VECTOR(v) ((v).stor_begin)
------------------
182| |
183| 9.27k| *id = newvalue;
184| 9.27k| return IGRAPH_SUCCESS;
185| 9.27k| } else {
186| 304| *id = -1;
187| 304| return IGRAPH_SUCCESS;
188| 304| }
189| |
190| 2.23M| } else if (key[diff] == '\0' && add) {
------------------
| Branch (190:20): [True: 2.12k, False: 16.1k]
| Branch (190:41): [True: 1.74k, False: 382]
------------------
191| |
192| | /* ------------------------------------ */
193| | /* key is prefix of str, the node has to be cut */
194| 1.74k| char *str2;
195| |
196| 1.74k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 1.74k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 3.48k| (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.74k, Folded]
| | | | ------------------
| | ------------------
------------------
197| 1.74k| IGRAPH_CHECK_OOM(node, "Cannot add to trie.");
------------------
| | 709| 1.74k| do { \
| | 710| 1.74k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.74k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.74k]
| | | | ------------------
| | ------------------
| | 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.74k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.74k]
| | ------------------
------------------
198| 1.74k| IGRAPH_FINALLY(igraph_free, node);
------------------
| | 603| 1.74k| do { \
| | 604| 1.74k| /* the following branch makes the compiler check the compatibility of \
| | 605| 1.74k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 1.74k| * incorrect destructor function with the pointer */ \
| | 607| 1.74k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 1.74k]
| | ------------------
| | 608| 1.74k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 1.74k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 1.74k]
| | ------------------
------------------
199| |
200| 1.74k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1);
------------------
| | 62| 1.74k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 63| 1.74k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 1.74k| do { \
| | | | 604| 1.74k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.74k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.74k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.74k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.74k]
| | | | ------------------
| | | | 608| 1.74k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.74k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.74k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 1.74k]
| | ------------------
------------------
201| 1.74k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1);
------------------
| | 46| 1.74k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 47| 1.74k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 1.74k| do { \
| | | | 604| 1.74k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.74k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.74k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.74k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.74k]
| | | | ------------------
| | | | 608| 1.74k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.74k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.74k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 1.74k]
| | ------------------
------------------
202| 1.74k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1);
------------------
| | 119| 1.74k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 1.74k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 1.74k| do { \
| | | | 604| 1.74k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.74k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.74k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.74k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.74k]
| | | | ------------------
| | | | 608| 1.74k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.74k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.74k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 1.74k]
| | ------------------
------------------
203| 1.74k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff));
------------------
| | 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]
| | ------------------
------------------
204| |
205| 1.74k| VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 1.74k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 1.74k|#define VECTOR(v) ((v).stor_begin)
------------------
206| 1.74k| VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 1.74k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 1.74k|#define VECTOR(v) ((v).stor_begin)
------------------
207| |
208| 1.74k| str2 = strdup(str);
209| 1.74k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie.");
------------------
| | 709| 1.74k| do { \
| | 710| 1.74k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.74k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.74k]
| | | | ------------------
| | ------------------
| | 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.74k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.74k]
| | ------------------
------------------
210| 1.74k| IGRAPH_FINALLY(igraph_free, str2);
------------------
| | 603| 1.74k| do { \
| | 604| 1.74k| /* the following branch makes the compiler check the compatibility of \
| | 605| 1.74k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 1.74k| * incorrect destructor function with the pointer */ \
| | 607| 1.74k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 1.74k]
| | ------------------
| | 608| 1.74k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 1.74k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 1.74k]
| | ------------------
------------------
211| 1.74k| str2[diff] = '\0';
212| |
213| 1.74k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2));
------------------
| | 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]
| | ------------------
------------------
214| |
215| 1.74k| IGRAPH_FREE(str2);
------------------
| | 36| 1.74k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
216| 1.74k| IGRAPH_FINALLY_CLEAN(5);
217| |
218| 1.74k| VECTOR(t->values)[i] = newvalue;
------------------
| | 60| 1.74k|#define VECTOR(v) ((v).stor_begin)
------------------
219| 1.74k| VECTOR(t->children)[i] = node;
------------------
| | 60| 1.74k|#define VECTOR(v) ((v).stor_begin)
------------------
220| |
221| 1.74k| *id = newvalue;
222| 1.74k| return IGRAPH_SUCCESS;
223| |
224| 16.5k| } else if (add) {
------------------
| Branch (224:20): [True: 14.0k, False: 2.42k]
------------------
225| |
226| | /* ------------------------------------ */
227| | /* the first diff characters match */
228| 14.0k| char *str2;
229| |
230| 14.0k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 14.0k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 28.1k| (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.0k, Folded]
| | | | ------------------
| | ------------------
------------------
231| 14.0k| IGRAPH_CHECK_OOM(node, "Cannot add to trie.");
------------------
| | 709| 14.0k| do { \
| | 710| 14.0k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 14.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.0k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 14.0k]
| | ------------------
------------------
232| 14.0k| IGRAPH_FINALLY(igraph_free, node);
------------------
| | 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]
| | ------------------
------------------
233| |
234| 14.0k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2);
------------------
| | 62| 14.0k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 63| 14.0k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 14.0k]
| | ------------------
------------------
235| 14.0k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2);
------------------
| | 46| 14.0k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 47| 14.0k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 14.0k]
| | ------------------
------------------
236| 14.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 2);
------------------
| | 119| 14.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 14.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 14.0k]
| | ------------------
------------------
237| 14.0k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff));
------------------
| | 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]
| | ------------------
------------------
238| 14.0k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff));
------------------
| | 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]
| | ------------------
------------------
239| 14.0k| VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
240| 14.0k| VECTOR(node->children)[1] = 0;
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
241| 14.0k| VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
242| 14.0k| VECTOR(node->values)[1] = newvalue;
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
243| |
244| 14.0k| str2 = strdup(str);
245| 14.0k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie.");
------------------
| | 709| 14.0k| do { \
| | 710| 14.0k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 14.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.0k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 14.0k]
| | ------------------
------------------
246| |
247| 14.0k| str2[diff] = '\0';
248| 14.0k| IGRAPH_FINALLY(igraph_free, str2);
------------------
| | 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]
| | ------------------
------------------
249| |
250| 14.0k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, 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: 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]
| | ------------------
------------------
251| |
252| 14.0k| IGRAPH_FREE(str2);
------------------
| | 36| 14.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
253| 14.0k| IGRAPH_FINALLY_CLEAN(5);
254| |
255| 14.0k| VECTOR(t->values)[i] = -1;
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
256| 14.0k| VECTOR(t->children)[i] = node;
------------------
| | 60| 14.0k|#define VECTOR(v) ((v).stor_begin)
------------------
257| |
258| 14.0k| *id = newvalue;
259| 14.0k| return IGRAPH_SUCCESS;
260| 14.0k| } else {
261| |
262| | /* ------------------------------------------------- */
263| | /* No match, but we requested not to add the new key */
264| 2.42k| *id = -1;
265| 2.42k| return IGRAPH_SUCCESS;
266| 2.42k| }
267| 17.0M| }
268| |
269| | /* ------------------------------------ */
270| | /* Nothing matches */
271| |
272| 156k| if (add) {
------------------
| Branch (272:9): [True: 144k, False: 12.5k]
------------------
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| 144k| IGRAPH_CHECK(igraph_strvector_push_back(&t->strs, key));
------------------
| | 656| 144k| do { \
| | 657| 144k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 144k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 144k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 144k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 144k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 144k]
| | ------------------
------------------
278| 144k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t->children, NULL));
------------------
| | 656| 144k| do { \
| | 657| 144k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 144k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 144k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 144k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 144k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 144k]
| | ------------------
------------------
279| 144k| IGRAPH_CHECK(igraph_vector_int_push_back(&t->values, newvalue));
------------------
| | 656| 144k| do { \
| | 657| 144k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 144k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 144k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 144k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 144k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 144k]
| | ------------------
------------------
280| 144k| *id = newvalue;
281| 144k| } else {
282| 12.5k| *id = -1;
283| 12.5k| }
284| |
285| 156k| return IGRAPH_SUCCESS;
286| 156k|}
trie.c:igraph_i_strdiff:
111| 17.0M|static size_t igraph_i_strdiff(const char *str, const char *key) {
112| 17.0M| size_t diff = 0;
113| 294M| while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) {
------------------
| Branch (113:12): [True: 290M, False: 4.35M]
| Branch (113:33): [True: 287M, False: 2.23M]
| Branch (113:54): [True: 277M, False: 10.4M]
------------------
114| 277M| diff++;
115| 277M| }
116| 17.0M| return diff;
117| 17.0M|}
igraph_attribute_record_list_init:
109| 81.7k|igraph_error_t FUNCTION(init)(TYPE *v, igraph_int_t size) {
110| 81.7k| igraph_int_t alloc_size = size > 0 ? size : 1;
------------------
| Branch (110:31): [True: 6.43k, False: 75.3k]
------------------
111| 81.7k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 81.7k| do { \
| | 925| 81.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 81.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 81.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 81.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 81.7k]
| | ------------------
------------------
112| 81.7k| v->stor_begin = IGRAPH_CALLOC(alloc_size, ITEM_TYPE);
------------------
| | 33| 81.7k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 163k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 81.7k, False: 0]
| | | | | Branch (31:24): [True: 81.7k, False: 0]
| | | | | Branch (31:66): [True: 81.7k, False: 0]
| | | | ------------------
| | ------------------
------------------
113| 81.7k| if (v->stor_begin == 0) {
------------------
| Branch (113:9): [True: 0, False: 81.7k]
------------------
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| 81.7k| v->stor_end = v->stor_begin + alloc_size;
117| 81.7k| v->end = v->stor_begin + size;
118| |
119| 81.7k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin, v->end));
------------------
| | 656| 81.7k| do { \
| | 657| 81.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 81.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 81.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 81.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| 81.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 81.7k]
| | ------------------
------------------
120| |
121| 81.7k| return IGRAPH_SUCCESS;
122| 81.7k|}
igraph_attribute_record_list_init_copy:
141| 9.49k|igraph_error_t FUNCTION(init_copy)(TYPE* to, const TYPE* from) {
142| 9.49k| igraph_int_t i, size = FUNCTION(size)(from);
------------------
| | 161| 9.49k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 9.49k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
143| |
144| 9.49k| IGRAPH_CHECK(FUNCTION(init)(to, 0));
------------------
| | 656| 9.49k| do { \
| | 657| 9.49k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 9.49k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 9.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.49k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.49k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 9.49k]
| | ------------------
------------------
145| 9.49k| IGRAPH_FINALLY(FUNCTION(destroy), to);
------------------
| | 603| 9.49k| do { \
| | 604| 9.49k| /* the following branch makes the compiler check the compatibility of \
| | 605| 9.49k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 9.49k| * incorrect destructor function with the pointer */ \
| | 607| 9.49k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 9.49k]
| | ------------------
| | 608| 9.49k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 9.49k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 9.49k]
| | ------------------
------------------
146| |
147| 11.7k| for (i = 0; i < size; i++) {
------------------
| Branch (147:17): [True: 2.27k, False: 9.49k]
------------------
148| 2.27k| IGRAPH_CHECK(FUNCTION(push_back_copy)(to, FUNCTION(get_ptr)(from, i)));
------------------
| | 656| 2.27k| do { \
| | 657| 2.27k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.27k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.27k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.27k]
| | ------------------
------------------
149| 2.27k| }
150| |
151| 9.49k| IGRAPH_FINALLY_CLEAN(1);
152| |
153| 9.49k| return IGRAPH_SUCCESS;
154| 9.49k|}
igraph_attribute_record_list_destroy:
176| 81.7k|void FUNCTION(destroy)(TYPE *v) {
177| 81.7k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 81.7k| do { \
| | 925| 81.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 81.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 81.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 81.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 81.7k]
| | ------------------
------------------
178| |
179| 81.7k| if (v->stor_begin != 0) {
------------------
| Branch (179:9): [True: 81.7k, False: 0]
------------------
180| 81.7k| FUNCTION(clear)(v);
------------------
| | 161| 81.7k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 81.7k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
181| 81.7k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 81.7k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
182| | v->stor_begin = NULL;
183| 81.7k| }
184| 81.7k|}
igraph_attribute_record_list_capacity:
203| 13.1k|igraph_int_t FUNCTION(capacity)(const TYPE *v) {
204| 13.1k| return v->stor_end - v->stor_begin;
205| 13.1k|}
igraph_attribute_record_list_reserve:
233| 13.1k|igraph_error_t FUNCTION(reserve)(TYPE *v, igraph_int_t capacity) {
234| 13.1k| igraph_int_t current_capacity;
235| 13.1k| ITEM_TYPE *tmp;
------------------
| | 61| 13.1k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 13.1k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
236| |
237| 13.1k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 13.1k| do { \
| | 925| 13.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 13.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 13.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 13.1k]
| | ------------------
------------------
238| 13.1k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 13.1k| do { \
| | 925| 13.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 13.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 13.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 13.1k]
| | ------------------
------------------
239| 13.1k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 13.1k| do { \
| | 925| 13.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 13.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 13.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 13.1k]
| | ------------------
------------------
240| |
241| 13.1k| current_capacity = FUNCTION(capacity)(v);
------------------
| | 161| 13.1k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 13.1k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
242| |
243| 13.1k| if (capacity <= current_capacity) {
------------------
| Branch (243:9): [True: 0, False: 13.1k]
------------------
244| 0| return IGRAPH_SUCCESS;
245| 0| }
246| |
247| 13.1k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, ITEM_TYPE);
------------------
| | 35| 13.1k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 26.3k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 13.1k, False: 0]
| | | | | Branch (31:24): [True: 13.1k, False: 0]
| | | | | Branch (31:66): [True: 13.1k, False: 0]
| | | | ------------------
| | ------------------
------------------
248| 13.1k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for list.");
------------------
| | 709| 13.1k| do { \
| | 710| 13.1k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 13.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.1k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 13.1k]
| | ------------------
------------------
249| |
250| 13.1k| v->end = tmp + (v->end - v->stor_begin);
251| 13.1k| v->stor_begin = tmp;
252| 13.1k| v->stor_end = v->stor_begin + capacity;
253| |
254| 13.1k| return IGRAPH_SUCCESS;
255| 13.1k|}
igraph_attribute_record_list_size:
287| 1.96M|igraph_int_t FUNCTION(size)(const TYPE *v) {
288| 1.96M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.96M| do { \
| | 925| 1.96M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.96M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.96M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.96M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.96M]
| | ------------------
------------------
289| 1.96M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.96M| do { \
| | 925| 1.96M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.96M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.96M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.96M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.96M]
| | ------------------
------------------
290| 1.96M| return v->end - v->stor_begin;
291| 1.96M|}
igraph_attribute_record_list_clear:
357| 81.7k|void FUNCTION(clear)(TYPE *v) {
358| 81.7k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 81.7k| do { \
| | 925| 81.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 81.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 81.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 81.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 81.7k]
| | ------------------
------------------
359| 81.7k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 81.7k| do { \
| | 925| 81.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 81.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 81.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 81.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 81.7k]
| | ------------------
------------------
360| 81.7k| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin, v->end);
------------------
| | 162| 81.7k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 81.7k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
361| 81.7k| v->end = v->stor_begin;
362| 81.7k|}
igraph_attribute_record_list_get_ptr:
377| 5.62M|ITEM_TYPE *FUNCTION(get_ptr)(const TYPE *v, igraph_int_t pos) {
378| 5.62M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 5.62M| do { \
| | 925| 5.62M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 5.62M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.62M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 5.62M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 5.62M]
| | ------------------
------------------
379| 5.62M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 5.62M| do { \
| | 925| 5.62M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 5.62M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.62M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 5.62M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 5.62M]
| | ------------------
------------------
380| 5.62M| return v->stor_begin + pos;
381| 5.62M|}
igraph_attribute_record_list_push_back:
587| 21.5k|igraph_error_t FUNCTION(push_back)(TYPE *v, ITEM_TYPE *e) {
588| 21.5k| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v));
------------------
| | 656| 21.5k| do { \
| | 657| 21.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 21.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 21.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 21.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| 21.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 21.5k]
| | ------------------
------------------
589| 21.5k| *(v->end) = *e;
590| 21.5k| v->end += 1;
591| 21.5k| return IGRAPH_SUCCESS;
592| 21.5k|}
igraph_attribute_record_list_push_back_copy:
612| 2.27k|igraph_error_t FUNCTION(push_back_copy)(TYPE *v, const ITEM_TYPE *e) {
613| 2.27k| ITEM_TYPE copy;
------------------
| | 61| 2.27k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 2.27k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
614| 2.27k| IGRAPH_CHECK(INTERNAL_FUNCTION(copy_item)(©, e));
------------------
| | 656| 2.27k| do { \
| | 657| 2.27k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.27k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.27k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.27k]
| | ------------------
------------------
615| 2.27k| IGRAPH_FINALLY(INTERNAL_FUNCTION(destroy_item), ©);
------------------
| | 603| 2.27k| do { \
| | 604| 2.27k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.27k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.27k| * incorrect destructor function with the pointer */ \
| | 607| 2.27k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.27k]
| | ------------------
| | 608| 2.27k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.27k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.27k]
| | ------------------
------------------
616| 2.27k| IGRAPH_CHECK(FUNCTION(push_back)(v, ©));
------------------
| | 656| 2.27k| do { \
| | 657| 2.27k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.27k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.27k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.27k]
| | ------------------
------------------
617| 2.27k| IGRAPH_FINALLY_CLEAN(1);
618| 2.27k| return IGRAPH_SUCCESS;
619| 2.27k|}
igraph_attribute_record_list_push_back_new:
640| 31.5k|igraph_error_t FUNCTION(push_back_new)(TYPE *v, ITEM_TYPE** e) {
641| 31.5k| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v));
------------------
| | 656| 31.5k| do { \
| | 657| 31.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 31.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 31.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.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| 31.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 31.5k]
| | ------------------
------------------
642| 31.5k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_item)(v, v->end));
------------------
| | 656| 31.5k| do { \
| | 657| 31.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 31.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 31.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.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| 31.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 31.5k]
| | ------------------
------------------
643| 31.5k| if (e) {
------------------
| Branch (643:9): [True: 31.5k, False: 0]
------------------
644| 31.5k| *e = v->end;
645| 31.5k| }
646| 31.5k| v->end += 1;
647| 31.5k| return IGRAPH_SUCCESS;
648| 31.5k|}
attributes.c:igraph_i_attribute_record_list_init_slice:
1068| 81.7k|static igraph_error_t INTERNAL_FUNCTION(init_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) {
1069| 81.7k| ITEM_TYPE *current;
------------------
| | 61| 81.7k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 81.7k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
1070| 81.7k| igraph_error_t retval;
1071| |
1072| 88.1k| for (current = start; current < end; current++) {
------------------
| Branch (1072:27): [True: 6.43k, False: 81.7k]
------------------
1073| 6.43k| retval = INTERNAL_FUNCTION(init_item)(list, current);
------------------
| | 162| 6.43k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 6.43k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1074| 6.43k| if (retval) {
------------------
| Branch (1074:13): [True: 0, False: 6.43k]
------------------
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.43k| }
1079| |
1080| 81.7k| return IGRAPH_SUCCESS;
1081| 81.7k|}
attributes.c:igraph_i_attribute_record_list_destroy_slice:
1083| 81.7k|static void INTERNAL_FUNCTION(destroy_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) {
1084| 81.7k| IGRAPH_UNUSED(list);
------------------
| | 30| 81.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1085| 141k| for (; start < end; start++) {
------------------
| Branch (1085:12): [True: 59.5k, False: 81.7k]
------------------
1086| 59.5k| INTERNAL_FUNCTION(destroy_item)(start);
------------------
| | 162| 59.5k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 59.5k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1087| 59.5k| }
1088| 81.7k|}
attributes.c:igraph_i_attribute_record_list_expand_if_full:
1094| 53.0k|static igraph_error_t INTERNAL_FUNCTION(expand_if_full)(TYPE *v) {
1095| 53.0k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 53.0k| do { \
| | 925| 53.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 53.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 53.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 53.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 53.0k]
| | ------------------
------------------
1096| 53.0k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 53.0k| do { \
| | 925| 53.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 53.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 53.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 53.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 53.0k]
| | ------------------
------------------
1097| |
1098| 53.0k| if (v->stor_end == v->end) {
------------------
| Branch (1098:9): [True: 13.1k, False: 39.9k]
------------------
1099| 13.1k| igraph_int_t old_size = FUNCTION(size)(v);
------------------
| | 161| 13.1k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 13.1k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1100| 13.1k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 13.1k|# 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.1k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (1100:33): [True: 13.1k, False: 0]
------------------
1101| 13.1k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 13.1k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (1101:13): [True: 0, False: 13.1k]
------------------
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.1k| if (new_size == 0) {
------------------
| Branch (1104:13): [True: 0, False: 13.1k]
------------------
1105| 0| new_size = 1;
1106| 0| }
1107| 13.1k| IGRAPH_CHECK(FUNCTION(reserve)(v, new_size));
------------------
| | 656| 13.1k| do { \
| | 657| 13.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.1k]
| | ------------------
------------------
1108| 13.1k| }
1109| |
1110| 53.0k| return IGRAPH_SUCCESS;
1111| 53.0k|}
igraph_vector_int_pair_order:
119| 31.2k| igraph_vector_int_t* res, igraph_int_t nodes) {
120| 31.2k| igraph_int_t edges = igraph_vector_int_size(v);
121| 31.2k| igraph_vector_int_t ptr;
122| 31.2k| igraph_vector_int_t rad;
123| 31.2k| igraph_int_t i, j;
124| |
125| 31.2k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 31.2k| do { \
| | 925| 31.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 31.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 31.2k]
| | ------------------
------------------
126| 31.2k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 31.2k| do { \
| | 925| 31.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 31.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 31.2k]
| | ------------------
------------------
127| |
128| 31.2k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1);
------------------
| | 119| 31.2k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 31.2k| do { \
| | | | 657| 31.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 31.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 31.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| 31.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 31.2k]
| | | | ------------------
| | ------------------
| | 120| 31.2k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 31.2k| do { \
| | | | 604| 31.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 31.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 31.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 31.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 31.2k]
| | | | ------------------
| | | | 608| 31.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 31.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 31.2k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 31.2k]
| | ------------------
------------------
129| 31.2k| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges);
------------------
| | 119| 31.2k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 31.2k| do { \
| | | | 657| 31.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 31.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 31.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| 31.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 31.2k]
| | | | ------------------
| | ------------------
| | 120| 31.2k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 31.2k| do { \
| | | | 604| 31.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 31.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 31.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 31.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 31.2k]
| | | | ------------------
| | | | 608| 31.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 31.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 31.2k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 31.2k]
| | ------------------
------------------
130| 31.2k| IGRAPH_CHECK(igraph_vector_int_resize(res, edges));
------------------
| | 656| 31.2k| do { \
| | 657| 31.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 31.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.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| 31.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 31.2k]
| | ------------------
------------------
131| |
132| 3.54M| for (i = 0; i < edges; i++) {
------------------
| Branch (132:17): [True: 3.51M, False: 31.2k]
------------------
133| 3.51M| igraph_int_t radix = VECTOR(*v2)[i];
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
134| 3.51M| if (VECTOR(ptr)[radix] != 0) {
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (134:13): [True: 3.35M, False: 158k]
------------------
135| 3.35M| VECTOR(rad)[i] = VECTOR(ptr)[radix];
------------------
| | 60| 3.35M|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(rad)[i] = VECTOR(ptr)[radix];
------------------
| | 60| 3.35M|#define VECTOR(v) ((v).stor_begin)
------------------
136| 3.35M| }
137| 3.51M| VECTOR(ptr)[radix] = i + 1;
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
138| 3.51M| }
139| |
140| 31.2k| j = 0;
141| 360k| for (i = 0; i < nodes + 1; i++) {
------------------
| Branch (141:17): [True: 329k, False: 31.2k]
------------------
142| 329k| if (VECTOR(ptr)[i] != 0) {
------------------
| | 60| 329k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (142:13): [True: 158k, False: 170k]
------------------
143| 158k| igraph_int_t next = VECTOR(ptr)[i] - 1;
------------------
| | 60| 158k|#define VECTOR(v) ((v).stor_begin)
------------------
144| 158k| VECTOR(*res)[j++] = next;
------------------
| | 60| 158k|#define VECTOR(v) ((v).stor_begin)
------------------
145| 3.51M| while (VECTOR(rad)[next] != 0) {
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (145:20): [True: 3.35M, False: 158k]
------------------
146| 3.35M| next = VECTOR(rad)[next] - 1;
------------------
| | 60| 3.35M|#define VECTOR(v) ((v).stor_begin)
------------------
147| 3.35M| VECTOR(*res)[j++] = next;
------------------
| | 60| 3.35M|#define VECTOR(v) ((v).stor_begin)
------------------
148| 3.35M| }
149| 158k| }
150| 329k| }
151| |
152| 31.2k| igraph_vector_int_null(&ptr);
153| 31.2k| igraph_vector_int_null(&rad);
154| |
155| 3.54M| for (i = 0; i < edges; i++) {
------------------
| Branch (155:17): [True: 3.51M, False: 31.2k]
------------------
156| 3.51M| igraph_int_t edge = VECTOR(*res)[edges - i - 1];
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
157| 3.51M| igraph_int_t radix = VECTOR(*v)[edge];
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
158| 3.51M| if (VECTOR(ptr)[radix] != 0) {
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (158:13): [True: 3.35M, False: 158k]
------------------
159| 3.35M| VECTOR(rad)[edge] = VECTOR(ptr)[radix];
------------------
| | 60| 3.35M|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(rad)[edge] = VECTOR(ptr)[radix];
------------------
| | 60| 3.35M|#define VECTOR(v) ((v).stor_begin)
------------------
160| 3.35M| }
161| 3.51M| VECTOR(ptr)[radix] = edge + 1;
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
162| 3.51M| }
163| |
164| 31.2k| j = 0;
165| 360k| for (i = 0; i < nodes + 1; i++) {
------------------
| Branch (165:17): [True: 329k, False: 31.2k]
------------------
166| 329k| if (VECTOR(ptr)[i] != 0) {
------------------
| | 60| 329k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (166:13): [True: 158k, False: 170k]
------------------
167| 158k| igraph_int_t next = VECTOR(ptr)[i] - 1;
------------------
| | 60| 158k|#define VECTOR(v) ((v).stor_begin)
------------------
168| 158k| VECTOR(*res)[j++] = next;
------------------
| | 60| 158k|#define VECTOR(v) ((v).stor_begin)
------------------
169| 3.51M| while (VECTOR(rad)[next] != 0) {
------------------
| | 60| 3.51M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (169:20): [True: 3.35M, False: 158k]
------------------
170| 3.35M| next = VECTOR(rad)[next] - 1;
------------------
| | 60| 3.35M|#define VECTOR(v) ((v).stor_begin)
------------------
171| 3.35M| VECTOR(*res)[j++] = next;
------------------
| | 60| 3.35M|#define VECTOR(v) ((v).stor_begin)
------------------
172| 3.35M| }
173| 158k| }
174| 329k| }
175| |
176| 31.2k| igraph_vector_int_destroy(&ptr);
177| 31.2k| igraph_vector_int_destroy(&rad);
178| 31.2k| IGRAPH_FINALLY_CLEAN(2);
179| |
180| 31.2k| return IGRAPH_SUCCESS;
181| 31.2k|}
igraph_vector_init:
134| 30.7k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 30.7k| igraph_int_t alloc_size;
136| 30.7k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 30.7k| do { \
| | 925| 30.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 30.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 30.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 30.7k]
| | ------------------
------------------
137| 30.7k| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 10.1k, False: 20.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| 30.7k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 30.7k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 61.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 30.7k, False: 0]
| | | | | Branch (31:24): [True: 30.7k, False: 0]
| | | | | Branch (31:66): [True: 30.7k, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 30.7k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 30.7k| do { \
| | 710| 30.7k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 30.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.7k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 30.7k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 30.7k]
| | ------------------
------------------
145| 30.7k| v->stor_end = v->stor_begin + alloc_size;
146| 30.7k| v->end = v->stor_begin + size;
147| |
148| 30.7k| return IGRAPH_SUCCESS;
149| 30.7k|}
igraph_vector_destroy:
408| 30.7k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 30.7k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 30.7k| do { \
| | 925| 30.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 30.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 30.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 30.7k]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 30.7k| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 30.7k, False: 0]
------------------
413| 30.7k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 30.7k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 30.7k| }
416| 30.7k|}
igraph_vector_capacity:
436| 423k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 423k| return v->stor_end - v->stor_begin;
438| 423k|}
igraph_vector_reserve:
468| 417k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 417k| igraph_int_t current_capacity;
470| 417k| BASE *tmp;
------------------
| | 29| 417k| #define BASE igraph_real_t
------------------
471| |
472| 417k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 417k| do { \
| | 925| 417k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417k]
| | ------------------
------------------
473| 417k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 417k| do { \
| | 925| 417k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417k]
| | ------------------
------------------
474| 417k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 417k| do { \
| | 925| 417k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417k]
| | ------------------
------------------
475| |
476| 417k| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 170| 417k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 417k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 417k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
477| |
478| 417k| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 390k, False: 26.6k]
------------------
479| 390k| return IGRAPH_SUCCESS;
480| 390k| }
481| |
482| 26.6k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 26.6k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 53.2k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 26.6k, False: 0]
| | | | | Branch (31:24): [True: 26.6k, False: 0]
| | | | | Branch (31:66): [True: 26.6k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 26.6k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 26.6k| do { \
| | 710| 26.6k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 26.6k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 26.6k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 26.6k]
| | ------------------
------------------
484| |
485| 26.6k| v->end = tmp + (v->end - v->stor_begin);
486| 26.6k| v->stor_begin = tmp;
487| 26.6k| v->stor_end = v->stor_begin + capacity;
488| |
489| 26.6k| return IGRAPH_SUCCESS;
490| 26.6k|}
igraph_vector_size:
522| 447k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 447k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 447k| do { \
| | 925| 447k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 447k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 447k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 447k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 447k]
| | ------------------
------------------
524| 447k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 447k| do { \
| | 925| 447k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 447k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 447k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 447k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 447k]
| | ------------------
------------------
525| 447k| return v->end - v->stor_begin;
526| 447k|}
igraph_vector_clear:
542| 389k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 389k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 389k| do { \
| | 925| 389k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 389k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 389k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 389k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 389k]
| | ------------------
------------------
544| 389k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 389k| do { \
| | 925| 389k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 389k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 389k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 389k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 389k]
| | ------------------
------------------
545| 389k| v->end = v->stor_begin;
546| 389k|}
igraph_vector_push_back:
573| 700k|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 700k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 700k| do { \
| | 925| 700k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 700k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 700k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 700k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 700k]
| | ------------------
------------------
575| 700k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 700k| do { \
| | 925| 700k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 700k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 700k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 700k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 700k]
| | ------------------
------------------
576| |
577| 700k| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 12.9k, False: 687k]
------------------
578| | /* full, allocate more storage */
579| 12.9k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 170| 12.9k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 12.9k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 12.9k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
580| 12.9k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 12.9k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 12.9k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 12.9k, False: 0]
------------------
581| 12.9k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 12.9k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 12.9k]
------------------
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| 12.9k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 12.9k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 12.9k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 12.9k| do { \
| | 657| 12.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 12.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 12.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 12.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| 12.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 12.9k]
| | ------------------
------------------
588| 12.9k| }
589| |
590| 700k| *(v->end) = e;
591| 700k| v->end += 1;
592| |
593| 700k| return IGRAPH_SUCCESS;
594| 700k|}
igraph_vector_sort:
958| 39|void FUNCTION(igraph_vector, sort)(TYPE(igraph_vector) *v) {
959| 39| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 39| do { \
| | 925| 39| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 39| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 39| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 39]
| | ------------------
------------------
960| 39| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 39| do { \
| | 925| 39| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 39| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 39| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 39]
| | ------------------
------------------
961| 39| igraph_qsort(v->stor_begin, FUNCTION(igraph_vector, size)(v),
------------------
| | 170| 39| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 39|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 39|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
962| 39| sizeof(BASE), FUNCTION(igraph_vector, sort_cmp));
------------------
| | 170| 39| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 39|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 39|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
963| 39|}
igraph_vector_resize:
1264| 400k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 400k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 400k| do { \
| | 925| 400k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 400k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 400k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 400k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 400k]
| | ------------------
------------------
1266| 400k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 400k| do { \
| | 925| 400k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 400k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 400k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 400k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 400k]
| | ------------------
------------------
1267| 400k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 400k| do { \
| | 657| 400k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 400k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 400k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 400k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 400k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 400k]
| | ------------------
------------------
1268| 400k| v->end = v->stor_begin + new_size;
1269| 400k| return IGRAPH_SUCCESS;
1270| 400k|}
igraph_vector_init_copy:
1538| 39|) {
1539| 39| igraph_int_t from_size;
1540| |
1541| 39| IGRAPH_ASSERT(from != NULL);
------------------
| | 924| 39| do { \
| | 925| 39| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 39| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 39| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 39]
| | ------------------
------------------
1542| 39| IGRAPH_ASSERT(from->stor_begin != NULL);
------------------
| | 924| 39| do { \
| | 925| 39| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 39| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 39| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 39]
| | ------------------
------------------
1543| |
1544| 39| from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 39| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 39|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 39|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
1545| 39| IGRAPH_CHECK(FUNCTION(igraph_vector, init)(to, from_size));
------------------
| | 656| 39| do { \
| | 657| 39| igraph_error_t igraph_i_ret = (expr); \
| | 658| 39| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 39| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 39]
| | ------------------
------------------
1546| |
1547| 39| memcpy(to->stor_begin, from->stor_begin, from_size * sizeof(BASE));
1548| |
1549| 39| return IGRAPH_SUCCESS;
1550| 39|}
igraph_vector_append:
2427| 5.84k| const TYPE(igraph_vector) *from) {
2428| 5.84k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 5.84k| do { \
| | 925| 5.84k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 5.84k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.84k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 5.84k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 5.84k]
| | ------------------
------------------
2429| 5.84k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 5.84k| do { \
| | 925| 5.84k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 5.84k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.84k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 5.84k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 5.84k]
| | ------------------
------------------
2430| |
2431| 5.84k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 170| 5.84k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 5.84k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 5.84k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2432| 5.84k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 5.84k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 5.84k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 5.84k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2433| 5.84k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 170| 5.84k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 5.84k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 5.84k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2434| 5.84k| igraph_int_t new_to_size;
2435| |
2436| 5.84k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 5.84k| do { \
| | 48| 5.84k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 5.84k| igraph_int_t _safe_sum; \
| | 50| 5.84k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 5.84k]
| | ------------------
| | 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| 5.84k| *(res) = _safe_sum; \
| | 54| 5.84k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 5.84k]
| | ------------------
------------------
2437| |
2438| 5.84k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 4.37k, False: 1.47k]
------------------
2439| 4.37k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 4.37k|# 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.37k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 4.37k, False: 0]
------------------
2440| 4.37k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 3.41k, False: 953]
------------------
2441| 3.41k| new_to_capacity = new_to_size;
2442| 3.41k| }
2443| 4.37k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 656| 4.37k| do { \
| | 657| 4.37k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.37k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.37k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.37k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.37k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.37k]
| | ------------------
------------------
2444| 4.37k| }
2445| |
2446| 5.84k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 5.84k| sizeof(BASE) * from_size);
2448| 5.84k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 5.84k| return IGRAPH_SUCCESS;
2451| 5.84k|}
igraph_vector_update:
2524| 368| const TYPE(igraph_vector) *from) {
2525| 368| igraph_int_t n = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 368| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 368|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 368|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2526| 368| IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, n));
------------------
| | 656| 368| do { \
| | 657| 368| igraph_error_t igraph_i_ret = (expr); \
| | 658| 368| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 368| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 368]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 368| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 368]
| | ------------------
------------------
2527| 368| memcpy(to->stor_begin, from->stor_begin, sizeof(BASE)*n);
2528| 368| return IGRAPH_SUCCESS;
2529| 368|}
igraph_vector_swap:
2541| 326|void FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) {
2542| |
2543| 326| TYPE(igraph_vector) tmp;
------------------
| | 171| 326| #define TYPE(a) CONCAT2(a,t)
| | ------------------
| | | | 20| 326|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 326|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2544| |
2545| 326| tmp = *v1;
2546| 326| *v1 = *v2;
2547| 326| *v2 = tmp;
2548| 326|}
igraph_vector_char_init:
134| 1.53M|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 1.53M| igraph_int_t alloc_size;
136| 1.53M| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 1.53M| do { \
| | 925| 1.53M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.53M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.53M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.53M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.53M]
| | ------------------
------------------
137| 1.53M| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 1.50M, False: 28.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| 1.53M| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 1.53M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 3.07M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 1.53M, False: 0]
| | | | | Branch (31:24): [True: 1.53M, False: 0]
| | | | | Branch (31:66): [True: 1.53M, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 1.53M| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 1.53M| do { \
| | 710| 1.53M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.53M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.53M]
| | | | ------------------
| | ------------------
| | 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.53M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.53M]
| | ------------------
------------------
145| 1.53M| v->stor_end = v->stor_begin + alloc_size;
146| 1.53M| v->end = v->stor_begin + size;
147| |
148| 1.53M| return IGRAPH_SUCCESS;
149| 1.53M|}
igraph_vector_char_view:
182| 40.8M| const BASE *data, igraph_int_t length) {
183| |
184| 40.8M| static const BASE dummy = ZERO;
------------------
| | 48| 40.8M| #define ZERO 0
------------------
185| 40.8M| TYPE(igraph_vector) v;
------------------
| | 179| 40.8M| #define TYPE(a) CONCAT3(a,SHORT,t)
| | ------------------
| | | | 22| 40.8M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 40.8M|#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| 40.8M| if (length == 0) {
------------------
| Branch (190:9): [True: 194, False: 40.8M]
------------------
191| 194| data = &dummy;
192| 40.8M| } else {
193| 40.8M| IGRAPH_ASSERT(data != NULL);
------------------
| | 924| 40.8M| do { \
| | 925| 40.8M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 40.8M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 40.8M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 40.8M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 40.8M]
| | ------------------
------------------
194| 40.8M| }
195| |
196| 40.8M| v.stor_begin = (BASE*)data;
197| 40.8M| v.stor_end = (BASE*)data + length;
198| 40.8M| v.end = v.stor_end;
199| 40.8M| return v;
200| 40.8M|}
igraph_vector_char_destroy:
408| 1.53M|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 1.53M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.53M| do { \
| | 925| 1.53M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.53M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.53M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.53M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.53M]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 1.53M| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 1.53M, False: 0]
------------------
413| 1.53M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 1.53M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 1.53M| }
416| 1.53M|}
igraph_vector_char_capacity:
436| 42.4M|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 42.4M| return v->stor_end - v->stor_begin;
438| 42.4M|}
igraph_vector_char_reserve:
468| 1.62M|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 1.62M| igraph_int_t current_capacity;
470| 1.62M| BASE *tmp;
------------------
| | 43| 1.62M| #define BASE char
------------------
471| |
472| 1.62M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.62M| do { \
| | 925| 1.62M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.62M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.62M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.62M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.62M]
| | ------------------
------------------
473| 1.62M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.62M| do { \
| | 925| 1.62M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.62M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.62M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.62M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.62M]
| | ------------------
------------------
474| 1.62M| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 1.62M| do { \
| | 925| 1.62M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.62M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.62M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.62M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.62M]
| | ------------------
------------------
475| |
476| 1.62M| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 178| 1.62M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 1.62M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 1.62M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
477| |
478| 1.62M| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 976k, False: 651k]
------------------
479| 976k| return IGRAPH_SUCCESS;
480| 976k| }
481| |
482| 651k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 651k|#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: 651k, False: 0]
| | | | | Branch (31:24): [True: 651k, False: 0]
| | | | | Branch (31:66): [True: 651k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 651k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 651k| do { \
| | 710| 651k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 651k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 651k]
| | | | ------------------
| | ------------------
| | 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| 651k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 651k]
| | ------------------
------------------
484| |
485| 651k| v->end = tmp + (v->end - v->stor_begin);
486| 651k| v->stor_begin = tmp;
487| 651k| v->stor_end = v->stor_begin + capacity;
488| |
489| 651k| return IGRAPH_SUCCESS;
490| 651k|}
igraph_vector_char_size:
522| 82.7M|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 82.7M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 82.7M| do { \
| | 925| 82.7M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 82.7M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.7M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 82.7M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 82.7M]
| | ------------------
------------------
524| 82.7M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 82.7M| do { \
| | 925| 82.7M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 82.7M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.7M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 82.7M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 82.7M]
| | ------------------
------------------
525| 82.7M| return v->end - v->stor_begin;
526| 82.7M|}
igraph_vector_char_clear:
542| 819k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 819k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 819k| do { \
| | 925| 819k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 819k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 819k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 819k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 819k]
| | ------------------
------------------
544| 819k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 819k| do { \
| | 925| 819k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 819k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 819k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 819k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 819k]
| | ------------------
------------------
545| 819k| v->end = v->stor_begin;
546| 819k|}
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: 631k, False: 783k]
------------------
578| | /* full, allocate more storage */
579| 631k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 178| 631k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 631k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 631k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
580| 631k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 631k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 631k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 631k, False: 0]
------------------
581| 631k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 631k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 631k]
------------------
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| 631k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 631k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 631k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 631k| do { \
| | 657| 631k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 631k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 631k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 631k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 631k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 631k]
| | ------------------
------------------
588| 631k| }
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| 986k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 986k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 986k| do { \
| | 925| 986k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 986k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 986k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 986k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 986k]
| | ------------------
------------------
1266| 986k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 986k| do { \
| | 925| 986k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 986k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 986k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 986k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 986k]
| | ------------------
------------------
1267| 986k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 986k| do { \
| | 657| 986k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 986k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 986k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 986k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 986k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 986k]
| | ------------------
------------------
1268| 986k| v->end = v->stor_begin + new_size;
1269| 986k| return IGRAPH_SUCCESS;
1270| 986k|}
igraph_vector_char_append:
2427| 40.8M| const TYPE(igraph_vector) *from) {
2428| 40.8M| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 40.8M| do { \
| | 925| 40.8M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 40.8M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 40.8M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 40.8M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 40.8M]
| | ------------------
------------------
2429| 40.8M| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 40.8M| do { \
| | 925| 40.8M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 40.8M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 40.8M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 40.8M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 40.8M]
| | ------------------
------------------
2430| |
2431| 40.8M| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 178| 40.8M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 40.8M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 40.8M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2432| 40.8M| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 178| 40.8M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 40.8M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 40.8M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2433| 40.8M| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 178| 40.8M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 40.8M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 40.8M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2434| 40.8M| igraph_int_t new_to_size;
2435| |
2436| 40.8M| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 40.8M| do { \
| | 48| 40.8M| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 40.8M| igraph_int_t _safe_sum; \
| | 50| 40.8M| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 40.8M]
| | ------------------
| | 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| 40.8M| *(res) = _safe_sum; \
| | 54| 40.8M| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 40.8M]
| | ------------------
------------------
2437| |
2438| 40.8M| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 10.6k, False: 40.8M]
------------------
2439| 10.6k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 10.6k|# 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.6k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 10.6k, False: 0]
------------------
2440| 10.6k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 3.30k, False: 7.31k]
------------------
2441| 3.30k| new_to_capacity = new_to_size;
2442| 3.30k| }
2443| 10.6k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 656| 10.6k| do { \
| | 657| 10.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10.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| 10.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.6k]
| | ------------------
------------------
2444| 10.6k| }
2445| |
2446| 40.8M| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 40.8M| sizeof(BASE) * from_size);
2448| 40.8M| to->end = to->stor_begin + new_to_size;
2449| |
2450| 40.8M| return IGRAPH_SUCCESS;
2451| 40.8M|}
igraph_vector_bool_init:
134| 14.1k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 14.1k| igraph_int_t alloc_size;
136| 14.1k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 14.1k| do { \
| | 925| 14.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 14.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 14.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 14.1k]
| | ------------------
------------------
137| 14.1k| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 6.43k, False: 7.74k]
------------------
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| 14.1k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 14.1k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 28.3k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 14.1k, False: 0]
| | | | | Branch (31:24): [True: 14.1k, False: 0]
| | | | | Branch (31:66): [True: 14.1k, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 14.1k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 14.1k| do { \
| | 710| 14.1k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 14.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.1k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 14.1k]
| | ------------------
------------------
145| 14.1k| v->stor_end = v->stor_begin + alloc_size;
146| 14.1k| v->end = v->stor_begin + size;
147| |
148| 14.1k| return IGRAPH_SUCCESS;
149| 14.1k|}
igraph_vector_bool_destroy:
408| 14.1k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 14.1k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 14.1k| do { \
| | 925| 14.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 14.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 14.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 14.1k]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 14.1k| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 14.1k, False: 0]
------------------
413| 14.1k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 14.1k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 14.1k| }
416| 14.1k|}
igraph_vector_bool_capacity:
436| 46.4k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 46.4k| return v->stor_end - v->stor_begin;
438| 46.4k|}
igraph_vector_bool_reserve:
468| 44.5k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 44.5k| igraph_int_t current_capacity;
470| 44.5k| BASE *tmp;
------------------
| | 53| 44.5k| #define BASE igraph_bool_t
------------------
471| |
472| 44.5k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 44.5k| do { \
| | 925| 44.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 44.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 44.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 44.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 44.5k]
| | ------------------
------------------
473| 44.5k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 44.5k| do { \
| | 925| 44.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 44.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 44.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 44.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 44.5k]
| | ------------------
------------------
474| 44.5k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 44.5k| do { \
| | 925| 44.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 44.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 44.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 44.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 44.5k]
| | ------------------
------------------
475| |
476| 44.5k| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 175| 44.5k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 44.5k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
477| |
478| 44.5k| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 33.4k, False: 11.0k]
------------------
479| 33.4k| return IGRAPH_SUCCESS;
480| 33.4k| }
481| |
482| 11.0k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 11.0k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 22.0k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 11.0k, False: 0]
| | | | | Branch (31:24): [True: 11.0k, False: 0]
| | | | | Branch (31:66): [True: 11.0k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 11.0k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 11.0k| do { \
| | 710| 11.0k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 11.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.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| 11.0k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 11.0k]
| | ------------------
------------------
484| |
485| 11.0k| v->end = tmp + (v->end - v->stor_begin);
486| 11.0k| v->stor_begin = tmp;
487| 11.0k| v->stor_end = v->stor_begin + capacity;
488| |
489| 11.0k| return IGRAPH_SUCCESS;
490| 11.0k|}
igraph_vector_bool_size:
522| 63.0k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 63.0k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 63.0k| do { \
| | 925| 63.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 63.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 63.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 63.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 63.0k]
| | ------------------
------------------
524| 63.0k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 63.0k| do { \
| | 925| 63.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 63.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 63.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 63.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 63.0k]
| | ------------------
------------------
525| 63.0k| return v->end - v->stor_begin;
526| 63.0k|}
igraph_vector_bool_clear:
542| 31.1k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 31.1k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 31.1k| do { \
| | 925| 31.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 31.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 31.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 31.1k]
| | ------------------
------------------
544| 31.1k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 31.1k| do { \
| | 925| 31.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 31.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 31.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 31.1k]
| | ------------------
------------------
545| 31.1k| v->end = v->stor_begin;
546| 31.1k|}
igraph_vector_bool_push_back:
573| 408|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 408| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 408| do { \
| | 925| 408| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 408| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 408]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 408| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 408]
| | ------------------
------------------
575| 408| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 408| do { \
| | 925| 408| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 408| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 408]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 408| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 408]
| | ------------------
------------------
576| |
577| 408| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 0, False: 408]
------------------
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| 408| *(v->end) = e;
591| 408| v->end += 1;
592| |
593| 408| return IGRAPH_SUCCESS;
594| 408|}
igraph_vector_bool_resize:
1264| 43.2k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 43.2k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 43.2k| do { \
| | 925| 43.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 43.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 43.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 43.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 43.2k]
| | ------------------
------------------
1266| 43.2k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 43.2k| do { \
| | 925| 43.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 43.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 43.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 43.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 43.2k]
| | ------------------
------------------
1267| 43.2k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 43.2k| do { \
| | 657| 43.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 43.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 43.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 43.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| 43.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 43.2k]
| | ------------------
------------------
1268| 43.2k| v->end = v->stor_begin + new_size;
1269| 43.2k| return IGRAPH_SUCCESS;
1270| 43.2k|}
igraph_vector_bool_append:
2427| 1.94k| const TYPE(igraph_vector) *from) {
2428| 1.94k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 1.94k| do { \
| | 925| 1.94k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.94k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.94k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.94k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.94k]
| | ------------------
------------------
2429| 1.94k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 1.94k| do { \
| | 925| 1.94k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.94k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.94k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.94k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.94k]
| | ------------------
------------------
2430| |
2431| 1.94k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 175| 1.94k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 1.94k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2432| 1.94k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 175| 1.94k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 1.94k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2433| 1.94k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 175| 1.94k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 1.94k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2434| 1.94k| igraph_int_t new_to_size;
2435| |
2436| 1.94k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 1.94k| do { \
| | 48| 1.94k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 1.94k| igraph_int_t _safe_sum; \
| | 50| 1.94k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 1.94k]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 1.94k| *(res) = _safe_sum; \
| | 54| 1.94k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 1.94k]
| | ------------------
------------------
2437| |
2438| 1.94k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 1.25k, False: 688]
------------------
2439| 1.25k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 1.25k|# 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.25k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 1.25k, False: 0]
------------------
2440| 1.25k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 1.05k, False: 199]
------------------
2441| 1.05k| new_to_capacity = new_to_size;
2442| 1.05k| }
2443| 1.25k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 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]
| | ------------------
------------------
2444| 1.25k| }
2445| |
2446| 1.94k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 1.94k| sizeof(BASE) * from_size);
2448| 1.94k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 1.94k| return IGRAPH_SUCCESS;
2451| 1.94k|}
igraph_vector_bool_update:
2524| 266| const TYPE(igraph_vector) *from) {
2525| 266| igraph_int_t n = FUNCTION(igraph_vector, size)(from);
------------------
| | 175| 266| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 266|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2526| 266| IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, n));
------------------
| | 656| 266| do { \
| | 657| 266| igraph_error_t igraph_i_ret = (expr); \
| | 658| 266| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 266| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 266]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 266| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 266]
| | ------------------
------------------
2527| 266| memcpy(to->stor_begin, from->stor_begin, sizeof(BASE)*n);
2528| 266| return IGRAPH_SUCCESS;
2529| 266|}
igraph_vector_int_init:
134| 1.94M|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 1.94M| igraph_int_t alloc_size;
136| 1.94M| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 1.94M| do { \
| | 925| 1.94M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.94M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.94M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.94M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.94M]
| | ------------------
------------------
137| 1.94M| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 1.62M, False: 325k]
------------------
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.94M| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 1.94M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 3.89M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 1.94M, False: 0]
| | | | | Branch (31:24): [True: 1.94M, False: 0]
| | | | | Branch (31:66): [True: 1.94M, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 1.94M| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 1.94M| do { \
| | 710| 1.94M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.94M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.94M]
| | | | ------------------
| | ------------------
| | 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.94M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.94M]
| | ------------------
------------------
145| 1.94M| v->stor_end = v->stor_begin + alloc_size;
146| 1.94M| v->end = v->stor_begin + size;
147| |
148| 1.94M| return IGRAPH_SUCCESS;
149| 1.94M|}
igraph_vector_int_destroy:
408| 1.94M|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 1.94M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.94M| do { \
| | 925| 1.94M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.94M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.94M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.94M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.94M]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 1.94M| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 1.94M, False: 0]
------------------
413| 1.94M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 1.94M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 1.94M| }
416| 1.94M|}
igraph_vector_int_capacity:
436| 1.13M|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 1.13M| return v->stor_end - v->stor_begin;
438| 1.13M|}
igraph_vector_int_reserve:
468| 1.13M|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 1.13M| igraph_int_t current_capacity;
470| 1.13M| BASE *tmp;
------------------
| | 66| 1.13M| #define BASE igraph_int_t
------------------
471| |
472| 1.13M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.13M| do { \
| | 925| 1.13M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.13M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.13M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.13M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.13M]
| | ------------------
------------------
473| 1.13M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.13M| do { \
| | 925| 1.13M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.13M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.13M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.13M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.13M]
| | ------------------
------------------
474| 1.13M| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 1.13M| do { \
| | 925| 1.13M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.13M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.13M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.13M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.13M]
| | ------------------
------------------
475| |
476| 1.13M| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 178| 1.13M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 1.13M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 1.13M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
477| |
478| 1.13M| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 318k, False: 815k]
------------------
479| 318k| return IGRAPH_SUCCESS;
480| 318k| }
481| |
482| 815k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 815k|#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: 815k, False: 0]
| | | | | Branch (31:24): [True: 815k, False: 0]
| | | | | Branch (31:66): [True: 815k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 815k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 815k| do { \
| | 710| 815k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 815k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 815k]
| | | | ------------------
| | ------------------
| | 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| 815k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 815k]
| | ------------------
------------------
484| |
485| 815k| v->end = tmp + (v->end - v->stor_begin);
486| 815k| v->stor_begin = tmp;
487| 815k| v->stor_end = v->stor_begin + capacity;
488| |
489| 815k| return IGRAPH_SUCCESS;
490| 815k|}
igraph_vector_int_empty:
503| 422k|igraph_bool_t FUNCTION(igraph_vector, empty)(const TYPE(igraph_vector) *v) {
504| 422k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 422k| do { \
| | 925| 422k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 422k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 422k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 422k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 422k]
| | ------------------
------------------
505| 422k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 422k| do { \
| | 925| 422k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 422k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 422k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 422k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 422k]
| | ------------------
------------------
506| 422k| return v->stor_begin == v->end;
507| 422k|}
igraph_vector_int_size:
522| 7.20M|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 7.20M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 7.20M| do { \
| | 925| 7.20M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 7.20M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.20M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 7.20M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 7.20M]
| | ------------------
------------------
524| 7.20M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 7.20M| do { \
| | 925| 7.20M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 7.20M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.20M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 7.20M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 7.20M]
| | ------------------
------------------
525| 7.20M| return v->end - v->stor_begin;
526| 7.20M|}
igraph_vector_int_push_back:
573| 8.45M|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 8.45M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 8.45M| do { \
| | 925| 8.45M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.45M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.45M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.45M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.45M]
| | ------------------
------------------
575| 8.45M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 8.45M| do { \
| | 925| 8.45M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.45M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.45M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.45M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.45M]
| | ------------------
------------------
576| |
577| 8.45M| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 723k, False: 7.73M]
------------------
578| | /* full, allocate more storage */
579| 723k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 178| 723k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 723k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 723k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
580| 723k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 723k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 723k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 723k, False: 0]
------------------
581| 723k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 723k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 723k]
------------------
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| 723k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 723k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 723k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 723k| do { \
| | 657| 723k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 723k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 723k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 723k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 723k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 723k]
| | ------------------
------------------
588| 723k| }
589| |
590| 8.45M| *(v->end) = e;
591| 8.45M| v->end += 1;
592| |
593| 8.45M| return IGRAPH_SUCCESS;
594| 8.45M|}
igraph_vector_int_null:
725| 73.8k|void FUNCTION(igraph_vector, null)(TYPE(igraph_vector) *v) {
726| 73.8k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 73.8k| do { \
| | 925| 73.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 73.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 73.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 73.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 73.8k]
| | ------------------
------------------
727| 73.8k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 73.8k| do { \
| | 925| 73.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 73.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 73.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 73.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 73.8k]
| | ------------------
------------------
728| 73.8k| if (FUNCTION(igraph_vector, size)(v) > 0) {
------------------
| | 178| 73.8k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 73.8k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 73.8k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
| Branch (728:9): [True: 64.0k, False: 9.86k]
------------------
729| 64.0k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v));
------------------
| | 178| 64.0k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 64.0k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 64.0k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
730| 64.0k| }
731| 73.8k|}
igraph_vector_int_pop_back:
838| 417k|BASE FUNCTION(igraph_vector, pop_back)(TYPE(igraph_vector) *v) {
839| 417k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 417k| do { \
| | 925| 417k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417k]
| | ------------------
------------------
840| 417k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 417k| do { \
| | 925| 417k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417k]
| | ------------------
------------------
841| 417k| IGRAPH_ASSERT(v->end != NULL);
------------------
| | 924| 417k| do { \
| | 925| 417k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417k]
| | ------------------
------------------
842| 417k| IGRAPH_ASSERT(v->end != v->stor_begin);
------------------
| | 924| 417k| do { \
| | 925| 417k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 417k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 417k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 417k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 417k]
| | ------------------
------------------
843| |
844| 417k| (v->end)--;
845| |
846| 417k| return *(v->end);
847| 417k|}
igraph_vector_int_resize:
1264| 288k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 288k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 288k| do { \
| | 925| 288k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 288k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 288k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 288k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 288k]
| | ------------------
------------------
1266| 288k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 288k| do { \
| | 925| 288k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 288k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 288k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 288k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 288k]
| | ------------------
------------------
1267| 288k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 288k| do { \
| | 657| 288k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 288k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 288k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 288k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 288k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 288k]
| | ------------------
------------------
1268| 288k| v->end = v->stor_begin + new_size;
1269| 288k| return IGRAPH_SUCCESS;
1270| 288k|}
igraph_vector_int_max:
1327| 2.25k|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector) *v) {
1328| 2.25k| BASE max;
------------------
| | 66| 2.25k| #define BASE igraph_int_t
------------------
1329| 2.25k| BASE *ptr;
------------------
| | 66| 2.25k| #define BASE igraph_int_t
------------------
1330| 2.25k| IGRAPH_ASSERT(!FUNCTION(igraph_vector, empty)(v));
------------------
| | 924| 2.25k| do { \
| | 925| 2.25k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.25k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.25k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.25k]
| | ------------------
------------------
1331| 2.25k| max = *(v->stor_begin);
1332| |#if defined(BASE_IGRAPH_REAL)
1333| | if (isnan(max)) { return max; }; /* Result is NaN */
1334| |#endif
1335| 2.25k| ptr = v->stor_begin + 1;
1336| 702k| while (ptr < v->end) {
------------------
| Branch (1336:12): [True: 699k, False: 2.25k]
------------------
1337| 699k| if ((*ptr) > max) {
------------------
| Branch (1337:13): [True: 22.9k, False: 676k]
------------------
1338| 22.9k| max = *ptr;
1339| 22.9k| }
1340| |#if defined(BASE_IGRAPH_REAL)
1341| | else if (isnan(*ptr))
1342| | return *ptr; /* Result is NaN */
1343| |#endif
1344| 699k| ptr++;
1345| 699k| }
1346| 2.25k| return max;
1347| 2.25k|}
igraph_vector_int_isininterval:
1832| 15.6k| BASE high) {
1833| 15.6k| BASE *ptr;
------------------
| | 66| 15.6k| #define BASE igraph_int_t
------------------
1834| 15.6k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 15.6k| do { \
| | 925| 15.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 15.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 15.6k]
| | ------------------
------------------
1835| 15.6k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 15.6k| do { \
| | 925| 15.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 15.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 15.6k]
| | ------------------
------------------
1836| 3.53M| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (1836:31): [True: 3.51M, False: 15.6k]
------------------
1837| | /* Note that the following is not equivalent to *ptr < low || *ptr > high
1838| | * when *ptr is NaN! */
1839| 3.51M| if (!(*ptr >= low && *ptr <= high)) {
------------------
| Branch (1839:15): [True: 3.51M, False: 0]
| Branch (1839:30): [True: 3.51M, False: 0]
------------------
1840| 0| return 0;
1841| 0| }
1842| 3.51M| }
1843| 15.6k| return 1;
1844| 15.6k|}
igraph_vector_int_append:
2427| 2.47k| const TYPE(igraph_vector) *from) {
2428| 2.47k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 2.47k| do { \
| | 925| 2.47k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.47k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.47k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.47k]
| | ------------------
------------------
2429| 2.47k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 2.47k| do { \
| | 925| 2.47k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.47k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.47k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.47k]
| | ------------------
------------------
2430| |
2431| 2.47k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 178| 2.47k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.47k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.47k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2432| 2.47k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 178| 2.47k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.47k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.47k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2433| 2.47k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 178| 2.47k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.47k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.47k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2434| 2.47k| igraph_int_t new_to_size;
2435| |
2436| 2.47k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 2.47k| do { \
| | 48| 2.47k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 2.47k| igraph_int_t _safe_sum; \
| | 50| 2.47k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 2.47k]
| | ------------------
| | 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.47k| *(res) = _safe_sum; \
| | 54| 2.47k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 2.47k]
| | ------------------
------------------
2437| |
2438| 2.47k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 0, False: 2.47k]
------------------
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.47k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 2.47k| sizeof(BASE) * from_size);
2448| 2.47k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 2.47k| return IGRAPH_SUCCESS;
2451| 2.47k|}
vector.c:igraph_vector_sort_cmp:
924| 2.28k|static int FUNCTION(igraph_vector, sort_cmp)(const void *a, const void *b) {
925| 2.28k| const BASE *da = (const BASE *) a;
926| 2.28k| const BASE *db = (const BASE *) b;
927| |
928| 2.28k| return (*da > *db) - (*da < *db);
929| 2.28k|}
igraph_vector_ptr_init:
86| 3.21M|igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_int_t size) {
87| 3.21M| igraph_int_t alloc_size = size > 0 ? size : 1;
------------------
| Branch (87:31): [True: 3.04M, False: 174k]
------------------
88| 3.21M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 3.21M| do { \
| | 925| 3.21M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.21M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.21M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.21M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.21M]
| | ------------------
------------------
89| 3.21M| if (size < 0) {
------------------
| Branch (89:9): [True: 0, False: 3.21M]
------------------
90| 0| size = 0;
91| 0| }
92| 3.21M| v->stor_begin = IGRAPH_CALLOC(alloc_size, void*);
------------------
| | 33| 3.21M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 6.43M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 3.21M, False: 0]
| | | | | Branch (31:24): [True: 3.21M, False: 0]
| | | | | Branch (31:66): [True: 3.21M, False: 0]
| | | | ------------------
| | ------------------
------------------
93| 3.21M| if (v->stor_begin == 0) {
------------------
| Branch (93:9): [True: 0, False: 3.21M]
------------------
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.21M| v->stor_end = v->stor_begin + alloc_size;
97| 3.21M| v->end = v->stor_begin + size;
98| 3.21M| v->item_destructor = 0;
99| |
100| 3.21M| return IGRAPH_SUCCESS;
101| 3.21M|}
igraph_vector_ptr_destroy:
132| 3.21M|void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) {
133| 3.21M| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 3.21M| do { \
| | 925| 3.21M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.21M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.21M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.21M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.21M]
| | ------------------
------------------
134| 3.21M| if (v->stor_begin != 0) {
------------------
| Branch (134:9): [True: 3.21M, False: 0]
------------------
135| 3.21M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 3.21M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
136| | v->stor_begin = NULL;
137| 3.21M| }
138| 3.21M|}
igraph_vector_ptr_free_all:
170| 66.9k|void igraph_vector_ptr_free_all(igraph_vector_ptr_t* v) {
171| 66.9k| void **ptr;
172| 66.9k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 66.9k| do { \
| | 925| 66.9k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 66.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.9k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 66.9k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 66.9k]
| | ------------------
------------------
173| 66.9k| IGRAPH_ASSERT(v->stor_begin != 0);
------------------
| | 924| 66.9k| do { \
| | 925| 66.9k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 66.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.9k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 66.9k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 66.9k]
| | ------------------
------------------
174| |
175| 66.9k| igraph_i_vector_ptr_call_item_destructor_all(v);
176| 80.6k| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (176:31): [True: 13.7k, False: 66.9k]
------------------
177| | IGRAPH_FREE(*ptr);
------------------
| | 36| 13.7k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
178| 13.7k| }
179| 66.9k|}
igraph_vector_ptr_destroy_all:
199| 66.9k|void igraph_vector_ptr_destroy_all(igraph_vector_ptr_t* v) {
200| 66.9k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 66.9k| do { \
| | 925| 66.9k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 66.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.9k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 66.9k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 66.9k]
| | ------------------
------------------
201| 66.9k| IGRAPH_ASSERT(v->stor_begin != 0);
------------------
| | 924| 66.9k| do { \
| | 925| 66.9k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 66.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.9k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 66.9k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 66.9k]
| | ------------------
------------------
202| 66.9k| igraph_vector_ptr_free_all(v);
203| 66.9k| igraph_vector_ptr_set_item_destructor(v, 0);
204| 66.9k| igraph_vector_ptr_destroy(v);
205| 66.9k|}
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.84M|igraph_int_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v) {
292| 8.84M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 8.84M| do { \
| | 925| 8.84M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.84M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.84M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.84M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.84M]
| | ------------------
------------------
293| 8.84M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 8.84M| do { \
| | 925| 8.84M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.84M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.84M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.84M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.84M]
| | ------------------
------------------
294| 8.84M| return v->end - v->stor_begin;
295| 8.84M|}
igraph_vector_ptr_push_back:
360| 2.39M|igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) {
361| 2.39M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 2.39M| do { \
| | 925| 2.39M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.39M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.39M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.39M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.39M]
| | ------------------
------------------
362| 2.39M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 2.39M| do { \
| | 925| 2.39M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.39M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.39M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.39M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.39M]
| | ------------------
------------------
363| |
364| | /* full, allocate more storage */
365| 2.39M| if (v->stor_end == v->end) {
------------------
| Branch (365:9): [True: 1.31M, False: 1.07M]
------------------
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.39M| *(v->end) = e;
374| 2.39M| v->end += 1;
375| |
376| 2.39M| return IGRAPH_SUCCESS;
377| 2.39M|}
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| 133k| igraph_vector_ptr_t *v, igraph_finally_func_t *func) {
670| 133k| igraph_finally_func_t* result = v->item_destructor;
671| |
672| 133k| v->item_destructor = func;
673| |
674| 133k| return result;
675| 133k|}
vector_ptr.c:igraph_i_vector_ptr_call_item_destructor_all:
140| 66.9k|static void igraph_i_vector_ptr_call_item_destructor_all(igraph_vector_ptr_t* v) {
141| 66.9k| void **ptr;
142| |
143| 66.9k| if (v->item_destructor != 0) {
------------------
| Branch (143:9): [True: 66.9k, False: 0]
------------------
144| 80.6k| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (144:35): [True: 13.7k, False: 66.9k]
------------------
145| 13.7k| if (*ptr != 0) {
------------------
| Branch (145:17): [True: 13.7k, False: 0]
------------------
146| 13.7k| v->item_destructor(*ptr);
147| 13.7k| }
148| 13.7k| }
149| 66.9k| }
150| 66.9k|}
igraph_attribute_record_init:
126| 60.6k|) {
127| 60.6k| attr->name = NULL;
128| 60.6k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
129| 60.6k| attr->value.as_raw = NULL;
130| 60.6k| attr->default_value.string = NULL;
131| |
132| 60.6k| IGRAPH_CHECK(igraph_attribute_record_set_name(attr, name));
------------------
| | 656| 60.6k| do { \
| | 657| 60.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 60.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 60.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 60.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| 60.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 60.6k]
| | ------------------
------------------
133| 60.6k| IGRAPH_FINALLY(igraph_free, attr->name);
------------------
| | 603| 60.6k| do { \
| | 604| 60.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 60.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 60.6k| * incorrect destructor function with the pointer */ \
| | 607| 60.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 60.6k]
| | ------------------
| | 608| 60.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 60.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 60.6k]
| | ------------------
------------------
134| 60.6k| IGRAPH_CHECK(igraph_attribute_record_set_type(attr, type));
------------------
| | 656| 60.6k| do { \
| | 657| 60.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 60.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 60.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 60.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| 60.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 60.6k]
| | ------------------
------------------
135| 60.6k| IGRAPH_FINALLY_CLEAN(1);
136| |
137| 60.6k| return IGRAPH_SUCCESS;
138| 60.6k|}
igraph_attribute_record_init_copy:
159| 2.27k|) {
160| 2.27k| IGRAPH_CHECK(igraph_attribute_record_init(to, from->name, from->type));
------------------
| | 656| 2.27k| do { \
| | 657| 2.27k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.27k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.27k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.27k]
| | ------------------
------------------
161| |
162| 2.27k| switch (from->type) {
163| 368| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (163:9): [True: 368, False: 1.90k]
------------------
164| 368| IGRAPH_CHECK(igraph_vector_update(to->value.as_vector, from->value.as_vector));
------------------
| | 656| 368| do { \
| | 657| 368| igraph_error_t igraph_i_ret = (expr); \
| | 658| 368| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 368| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 368]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 368| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 368]
| | ------------------
------------------
165| 368| break;
166| |
167| 1.64k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (167:9): [True: 1.64k, False: 634]
------------------
168| 1.64k| IGRAPH_CHECK(igraph_strvector_update(to->value.as_strvector, from->value.as_strvector));
------------------
| | 656| 1.64k| do { \
| | 657| 1.64k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.64k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.64k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.64k]
| | ------------------
------------------
169| 1.64k| break;
170| |
171| 1.64k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (171:9): [True: 266, False: 2.00k]
------------------
172| 266| IGRAPH_CHECK(igraph_vector_bool_update(to->value.as_vector_bool, from->value.as_vector_bool));
------------------
| | 656| 266| do { \
| | 657| 266| igraph_error_t igraph_i_ret = (expr); \
| | 658| 266| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 266| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 266]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 266| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 266]
| | ------------------
------------------
173| 266| break;
174| |
175| 266| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (175:9): [True: 0, False: 2.27k]
------------------
176| 0| break;
177| |
178| 0| default:
------------------
| Branch (178:9): [True: 0, False: 2.27k]
------------------
179| 0| break;
180| 2.27k| }
181| |
182| 2.27k| return IGRAPH_SUCCESS;
183| 2.27k|}
igraph_attribute_record_destroy:
241| 63.7k|void igraph_attribute_record_destroy(igraph_attribute_record_t *attr) {
242| 63.7k| igraph_i_attribute_record_destroy_values(attr);
243| |
244| 63.7k| if (attr->name) {
------------------
| Branch (244:9): [True: 60.6k, False: 3.14k]
------------------
245| 60.6k| igraph_free(attr->name);
246| | attr->name = NULL;
247| 60.6k| }
248| 63.7k|}
igraph_attribute_record_check_type:
264| 1.56M|) {
265| 1.56M| if (type != attr->type) {
------------------
| Branch (265:9): [True: 1, False: 1.56M]
------------------
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.56M| return IGRAPH_SUCCESS;
286| 1.56M|}
igraph_attribute_record_size:
295| 461k|igraph_int_t igraph_attribute_record_size(const igraph_attribute_record_t *attr) {
296| 461k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 461k| do { \
| | 925| 461k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 461k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 461k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 461k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 461k]
| | ------------------
------------------
297| |
298| 461k| switch (attr->type) {
299| 16.8k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (299:9): [True: 16.8k, False: 445k]
------------------
300| 16.8k| return igraph_vector_size(attr->value.as_vector);
301| |
302| 430k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (302:9): [True: 430k, False: 31.2k]
------------------
303| 430k| return igraph_strvector_size(attr->value.as_strvector);
304| |
305| 13.9k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (305:9): [True: 13.9k, False: 448k]
------------------
306| 13.9k| return igraph_vector_bool_size(attr->value.as_vector_bool);
307| |
308| 390| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (308:9): [True: 390, False: 461k]
------------------
309| 390| return 0;
310| |
311| 0| default:
------------------
| Branch (311:9): [True: 0, False: 461k]
------------------
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| 461k| }
314| 461k|}
igraph_attribute_record_resize:
332| 426k|) {
333| 426k| igraph_int_t i;
334| 426k| igraph_vector_t *vec;
335| 426k| igraph_vector_bool_t *log;
336| 426k| igraph_strvector_t *str;
337| |
338| 426k| IGRAPH_ASSERT(attr != 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]
| | ------------------
------------------
339| |
340| 426k| switch (attr->type) {
341| |
342| 11.0k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (342:9): [True: 11.0k, False: 414k]
------------------
343| 11.0k| vec = attr->value.as_vector;
344| 11.0k| i = igraph_vector_size(vec);
345| 11.0k| IGRAPH_CHECK(igraph_vector_resize(vec, new_size));
------------------
| | 656| 11.0k| do { \
| | 657| 11.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.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| 11.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.0k]
| | ------------------
------------------
346| 257k| while (i < new_size) {
------------------
| Branch (346:20): [True: 245k, False: 11.0k]
------------------
347| 245k| VECTOR(*vec)[i++] = attr->default_value.numeric;
------------------
| | 60| 245k|#define VECTOR(v) ((v).stor_begin)
------------------
348| 245k| }
349| 11.0k| break;
350| |
351| 12.3k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (351:9): [True: 12.3k, False: 413k]
------------------
352| 12.3k| log = attr->value.as_vector_bool;
353| 12.3k| i = igraph_vector_bool_size(log);
354| 12.3k| IGRAPH_CHECK(igraph_vector_bool_resize(log, new_size));
------------------
| | 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]
| | ------------------
------------------
355| 32.6k| while (i < new_size) {
------------------
| Branch (355:20): [True: 20.3k, False: 12.3k]
------------------
356| 20.3k| VECTOR(*log)[i++] = attr->default_value.boolean;
------------------
| | 60| 20.3k|#define VECTOR(v) ((v).stor_begin)
------------------
357| 20.3k| }
358| 12.3k| break;
359| |
360| 402k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (360:9): [True: 402k, False: 23.3k]
------------------
361| 402k| str = attr->value.as_strvector;
362| 402k| if (attr->default_value.string == 0 || (*attr->default_value.string == 0)) {
------------------
| Branch (362:17): [True: 401k, False: 741]
| Branch (362:52): [True: 0, False: 741]
------------------
363| 401k| IGRAPH_CHECK(igraph_strvector_resize(str, new_size));
------------------
| | 656| 401k| do { \
| | 657| 401k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 401k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 401k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 401k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 401k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 401k]
| | ------------------
------------------
364| 401k| } else {
365| 741| i = igraph_strvector_size(str);
366| 741| IGRAPH_CHECK(igraph_strvector_resize(str, new_size));
------------------
| | 656| 741| do { \
| | 657| 741| igraph_error_t igraph_i_ret = (expr); \
| | 658| 741| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 741| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 741]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 741| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 741]
| | ------------------
------------------
367| 121k| while (i < new_size) {
------------------
| Branch (367:24): [True: 120k, False: 741]
------------------
368| 120k| IGRAPH_CHECK(igraph_strvector_set(str, i++, attr->default_value.string));
------------------
| | 656| 120k| do { \
| | 657| 120k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 120k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 120k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 120k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 120k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 120k]
| | ------------------
------------------
369| 120k| }
370| 741| }
371| 402k| break;
372| |
373| 402k| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (373:9): [True: 0, False: 426k]
------------------
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: 426k]
------------------
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| 426k| }
380| |
381| 426k| return IGRAPH_SUCCESS;
382| 426k|}
igraph_attribute_record_set_default_numeric:
399| 11.7k|) {
400| 11.7k| if (attr->type != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (400:9): [True: 0, False: 11.7k]
------------------
401| 0| return IGRAPH_EINVAL;
402| 0| }
403| |
404| 11.7k| attr->default_value.numeric = value;
405| 11.7k| return IGRAPH_SUCCESS;
406| 11.7k|}
igraph_attribute_record_set_default_boolean:
423| 1.46k|) {
424| 1.46k| if (attr->type != IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (424:9): [True: 0, False: 1.46k]
------------------
425| 0| return IGRAPH_EINVAL;
426| 0| }
427| |
428| 1.46k| attr->default_value.boolean = value;
429| 1.46k| return IGRAPH_SUCCESS;
430| 1.46k|}
igraph_attribute_record_set_default_string:
449| 970|) {
450| 970| char* copy;
451| |
452| 970| if (attr->type != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (452:9): [True: 0, False: 970]
------------------
453| 0| return IGRAPH_EINVAL;
454| 0| }
455| |
456| 970| if (value && (*value != 0)) {
------------------
| Branch (456:9): [True: 970, False: 0]
| Branch (456:18): [True: 970, False: 0]
------------------
457| 970| copy = strdup(value);
458| 970| IGRAPH_CHECK_OOM(copy, "Insufficient memory to duplicate default value.");
------------------
| | 709| 970| do { \
| | 710| 970| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 970| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 970]
| | | | ------------------
| | ------------------
| | 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| 970| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 970]
| | ------------------
------------------
459| 970| } else {
460| 0| copy = NULL;
461| 0| }
462| |
463| 970| if (attr->default_value.string) {
------------------
| Branch (463:9): [True: 223, False: 747]
------------------
464| 223| igraph_free(attr->default_value.string);
465| 223| }
466| 970| attr->default_value.string = copy;
467| |
468| 970| return IGRAPH_SUCCESS;
469| 970|}
igraph_attribute_record_set_name:
483| 98.5k|) {
484| 98.5k| char *new_name;
485| |
486| 98.5k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 98.5k| do { \
| | 925| 98.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 98.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 98.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 98.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 98.5k]
| | ------------------
------------------
487| |
488| 98.5k| if (name != NULL) {
------------------
| Branch (488:9): [True: 60.6k, False: 37.9k]
------------------
489| 60.6k| new_name = strdup(name);
490| 60.6k| IGRAPH_CHECK_OOM(new_name, "Insufficient memory for allocating attribute name.");
------------------
| | 709| 60.6k| do { \
| | 710| 60.6k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 60.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 60.6k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 60.6k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 60.6k]
| | ------------------
------------------
491| 60.6k| } else {
492| 37.9k| new_name = NULL;
493| 37.9k| }
494| |
495| 98.5k| if (attr->name) {
------------------
| Branch (495:9): [True: 0, False: 98.5k]
------------------
496| 0| igraph_free(attr->name);
497| 0| }
498| |
499| 98.5k| attr->name = new_name;
500| |
501| 98.5k| return IGRAPH_SUCCESS;
502| 98.5k|}
igraph_attribute_record_set_type:
539| 98.5k|) {
540| 98.5k| void *ptr;
541| |
542| 98.5k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 98.5k| do { \
| | 925| 98.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 98.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 98.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 98.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 98.5k]
| | ------------------
------------------
543| |
544| 98.5k| if (attr->type != type) {
------------------
| Branch (544:9): [True: 59.9k, False: 38.5k]
------------------
545| 59.9k| switch (type) {
546| 11.3k| case IGRAPH_ATTRIBUTE_NUMERIC: {
------------------
| Branch (546:13): [True: 11.3k, False: 48.6k]
------------------
547| 11.3k| igraph_vector_t *vec = IGRAPH_CALLOC(1, igraph_vector_t);
------------------
| | 33| 11.3k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 22.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.3k, Folded]
| | | | ------------------
| | ------------------
------------------
548| 11.3k| IGRAPH_CHECK_OOM(vec, "Insufficient memory for attribute record.");
------------------
| | 709| 11.3k| do { \
| | 710| 11.3k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.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| 11.3k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 11.3k]
| | ------------------
------------------
549| 11.3k| IGRAPH_FINALLY(igraph_free, vec);
------------------
| | 603| 11.3k| do { \
| | 604| 11.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 11.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 11.3k| * incorrect destructor function with the pointer */ \
| | 607| 11.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 11.3k]
| | ------------------
| | 608| 11.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 11.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 11.3k]
| | ------------------
------------------
550| 11.3k| IGRAPH_VECTOR_INIT_FINALLY(vec, 0);
------------------
| | 104| 11.3k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 11.3k| do { \
| | | | 657| 11.3k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 11.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 11.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| 11.3k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 11.3k]
| | | | ------------------
| | ------------------
| | 105| 11.3k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 11.3k| do { \
| | | | 604| 11.3k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 11.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 11.3k| * incorrect destructor function with the pointer */ \
| | | | 607| 11.3k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 11.3k]
| | | | ------------------
| | | | 608| 11.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 11.3k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 11.3k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 11.3k]
| | ------------------
------------------
551| 11.3k| ptr = vec;
552| 11.3k| }
553| 0| break;
554| |
555| 44.1k| case IGRAPH_ATTRIBUTE_STRING: {
------------------
| Branch (555:13): [True: 44.1k, False: 15.8k]
------------------
556| 44.1k| igraph_strvector_t *strvec = IGRAPH_CALLOC(1, igraph_strvector_t);
------------------
| | 33| 44.1k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 88.2k| (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: 44.1k, Folded]
| | | | ------------------
| | ------------------
------------------
557| 44.1k| IGRAPH_CHECK_OOM(strvec, "Insufficient memory for attribute record.");
------------------
| | 709| 44.1k| do { \
| | 710| 44.1k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 44.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 44.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| 44.1k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 44.1k]
| | ------------------
------------------
558| 44.1k| IGRAPH_FINALLY(igraph_free, strvec);
------------------
| | 603| 44.1k| do { \
| | 604| 44.1k| /* the following branch makes the compiler check the compatibility of \
| | 605| 44.1k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 44.1k| * incorrect destructor function with the pointer */ \
| | 607| 44.1k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 44.1k]
| | ------------------
| | 608| 44.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 44.1k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 44.1k]
| | ------------------
------------------
559| 44.1k| IGRAPH_STRVECTOR_INIT_FINALLY(strvec, 0);
------------------
| | 62| 44.1k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 44.1k| do { \
| | | | 657| 44.1k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 44.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 44.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 44.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| 44.1k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 44.1k]
| | | | ------------------
| | ------------------
| | 63| 44.1k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 44.1k| do { \
| | | | 604| 44.1k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 44.1k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 44.1k| * incorrect destructor function with the pointer */ \
| | | | 607| 44.1k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 44.1k]
| | | | ------------------
| | | | 608| 44.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 44.1k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 44.1k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 44.1k]
| | ------------------
------------------
560| 44.1k| ptr = strvec;
561| 44.1k| }
562| 0| break;
563| |
564| 4.55k| case IGRAPH_ATTRIBUTE_BOOLEAN: {
------------------
| Branch (564:13): [True: 4.55k, False: 55.4k]
------------------
565| 4.55k| igraph_vector_bool_t *boolvec = IGRAPH_CALLOC(1, igraph_vector_bool_t);
------------------
| | 33| 4.55k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 9.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: 4.55k, Folded]
| | | | ------------------
| | ------------------
------------------
566| 4.55k| IGRAPH_CHECK_OOM(boolvec, "Insufficient memory for attribute record.");
------------------
| | 709| 4.55k| do { \
| | 710| 4.55k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 4.55k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.55k]
| | | | ------------------
| | ------------------
| | 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.55k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 4.55k]
| | ------------------
------------------
567| 4.55k| IGRAPH_FINALLY(igraph_free, boolvec);
------------------
| | 603| 4.55k| do { \
| | 604| 4.55k| /* the following branch makes the compiler check the compatibility of \
| | 605| 4.55k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 4.55k| * incorrect destructor function with the pointer */ \
| | 607| 4.55k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 4.55k]
| | ------------------
| | 608| 4.55k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 4.55k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 4.55k]
| | ------------------
------------------
568| 4.55k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(boolvec, 0);
------------------
| | 109| 4.55k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 4.55k| do { \
| | | | 657| 4.55k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 4.55k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 4.55k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 4.55k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.55k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 4.55k]
| | | | ------------------
| | ------------------
| | 110| 4.55k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 4.55k| do { \
| | | | 604| 4.55k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 4.55k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 4.55k| * incorrect destructor function with the pointer */ \
| | | | 607| 4.55k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 4.55k]
| | | | ------------------
| | | | 608| 4.55k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 4.55k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 4.55k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 4.55k]
| | ------------------
------------------
569| 4.55k| ptr = boolvec;
570| 4.55k| }
571| 0| break;
572| |
573| 0| default:
------------------
| Branch (573:13): [True: 0, False: 59.9k]
------------------
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| 59.9k| }
576| |
577| 59.9k| igraph_i_attribute_record_set_type(attr, type, ptr);
578| 59.9k| IGRAPH_FINALLY_CLEAN(2);
579| 59.9k| }
580| |
581| 98.5k| return IGRAPH_SUCCESS;
582| 98.5k|}
igraph_i_attribute_init:
617| 15.6k|) {
618| 15.6k| graph->attr = NULL;
619| 15.6k| if (igraph_i_attribute_table) {
------------------
| Branch (619:9): [True: 15.6k, False: 0]
------------------
620| 15.6k| IGRAPH_CHECK(igraph_i_attribute_table->init(graph, attr));
------------------
| | 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]
| | ------------------
------------------
621| 15.6k| if (graph->attr == NULL) {
------------------
| Branch (621:13): [True: 0, False: 15.6k]
------------------
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| 15.6k| }
625| 15.6k| return IGRAPH_SUCCESS;
626| 15.6k|}
igraph_i_attribute_destroy:
628| 15.6k|void igraph_i_attribute_destroy(igraph_t *graph) {
629| 15.6k| if (graph->attr && igraph_i_attribute_table) {
------------------
| Branch (629:9): [True: 15.6k, False: 0]
| Branch (629:24): [True: 15.6k, False: 0]
------------------
630| 15.6k| igraph_i_attribute_table->destroy(graph);
631| 15.6k| }
632| | graph->attr = NULL;
633| 15.6k|}
igraph_i_attribute_add_vertices:
649| 31.2k|) {
650| 31.2k| if (igraph_i_attribute_table) {
------------------
| Branch (650:9): [True: 31.2k, False: 0]
------------------
651| 31.2k| return igraph_i_attribute_table->add_vertices(graph, nv, attr);
652| 31.2k| } else {
653| 0| return IGRAPH_SUCCESS;
654| 0| }
655| 31.2k|}
igraph_i_attribute_add_edges:
690| 15.6k|) {
691| 15.6k| if (igraph_i_attribute_table) {
------------------
| Branch (691:9): [True: 15.6k, False: 0]
------------------
692| 15.6k| return igraph_i_attribute_table->add_edges(graph, edges, attr);
693| 15.6k| } else {
694| 0| return IGRAPH_SUCCESS;
695| 0| }
696| 15.6k|}
igraph_i_attribute_get_info:
734| 9.53k| igraph_vector_int_t *etypes) {
735| 9.53k| if (igraph_i_attribute_table) {
------------------
| Branch (735:9): [True: 9.53k, False: 0]
------------------
736| 9.53k| return igraph_i_attribute_table->get_info(graph, gnames, gtypes,
737| 9.53k| vnames, vtypes,
738| 9.53k| enames, etypes);
739| 9.53k| } else {
740| 0| return IGRAPH_SUCCESS;
741| 0| }
742| 9.53k|}
igraph_i_attribute_has_attr:
746| 200k| const char *name) {
747| 200k| if (igraph_i_attribute_table) {
------------------
| Branch (747:9): [True: 200k, False: 0]
------------------
748| 200k| return igraph_i_attribute_table->has_attr(graph, type, name);
749| 200k| } else {
750| 0| return IGRAPH_SUCCESS;
751| 0| }
752| 200k|}
igraph_i_attribute_get_type:
757| 2.70k| const char *name) {
758| 2.70k| if (igraph_i_attribute_table) {
------------------
| Branch (758:9): [True: 2.70k, False: 0]
------------------
759| 2.70k| return igraph_i_attribute_table->get_type(graph, type, elemtype, name);
760| 2.70k| } else {
761| 0| return IGRAPH_SUCCESS;
762| 0| }
763| |
764| 2.70k|}
igraph_i_attribute_get_numeric_graph_attr:
768| 326| igraph_vector_t *value) {
769| 326| igraph_vector_clear(value);
770| 326| if (igraph_i_attribute_table) {
------------------
| Branch (770:9): [True: 326, False: 0]
------------------
771| 326| return igraph_i_attribute_table->get_numeric_graph_attr(graph, name, value);
772| 326| } else {
773| 0| return IGRAPH_SUCCESS;
774| 0| }
775| 326|}
igraph_i_attribute_get_numeric_vertex_attr:
780| 14.2k| igraph_vector_t *value) {
781| 14.2k| igraph_vector_clear(value);
782| 14.2k| if (igraph_i_attribute_table) {
------------------
| Branch (782:9): [True: 14.2k, False: 0]
------------------
783| 14.2k| return igraph_i_attribute_table->get_numeric_vertex_attr(graph, name, vs, value);
784| 14.2k| } else {
785| 0| return IGRAPH_SUCCESS;
786| 0| }
787| 14.2k|}
igraph_i_attribute_get_numeric_edge_attr:
792| 375k| igraph_vector_t *value) {
793| 375k| igraph_vector_clear(value);
794| 375k| if (igraph_i_attribute_table) {
------------------
| Branch (794:9): [True: 375k, False: 0]
------------------
795| 375k| return igraph_i_attribute_table->get_numeric_edge_attr(graph, name, es, value);
796| 375k| } else {
797| 0| return IGRAPH_SUCCESS;
798| 0| }
799| 375k|}
igraph_i_attribute_get_string_graph_attr:
803| 1.68k| igraph_strvector_t *value) {
804| 1.68k| igraph_strvector_clear(value);
805| 1.68k| if (igraph_i_attribute_table) {
------------------
| Branch (805:9): [True: 1.68k, False: 0]
------------------
806| 1.68k| return igraph_i_attribute_table->get_string_graph_attr(graph, name, value);
807| 1.68k| } else {
808| 0| return IGRAPH_SUCCESS;
809| 0| }
810| 1.68k|}
igraph_i_attribute_get_string_vertex_attr:
815| 97.9k| igraph_strvector_t *value) {
816| 97.9k| igraph_strvector_clear(value);
817| 97.9k| if (igraph_i_attribute_table) {
------------------
| Branch (817:9): [True: 97.9k, False: 0]
------------------
818| 97.9k| return igraph_i_attribute_table->get_string_vertex_attr(graph, name, vs, value);
819| 97.9k| } else {
820| 0| return IGRAPH_SUCCESS;
821| 0| }
822| 97.9k|}
igraph_i_attribute_get_string_edge_attr:
827| 1.04M| igraph_strvector_t *value) {
828| 1.04M| igraph_strvector_clear(value);
829| 1.04M| if (igraph_i_attribute_table) {
------------------
| Branch (829:9): [True: 1.04M, False: 0]
------------------
830| 1.04M| return igraph_i_attribute_table->get_string_edge_attr(graph, name, es, value);
831| 1.04M| } else {
832| 0| return IGRAPH_SUCCESS;
833| 0| }
834| 1.04M|}
igraph_i_attribute_get_bool_graph_attr:
838| 408| igraph_vector_bool_t *value) {
839| 408| igraph_vector_bool_clear(value);
840| 408| if (igraph_i_attribute_table) {
------------------
| Branch (840:9): [True: 408, False: 0]
------------------
841| 408| return igraph_i_attribute_table->get_bool_graph_attr(graph, name, value);
842| 408| } else {
843| 0| return IGRAPH_SUCCESS;
844| 0| }
845| 408|}
igraph_i_attribute_get_bool_vertex_attr:
850| 13.2k| igraph_vector_bool_t *value) {
851| 13.2k| igraph_vector_bool_clear(value);
852| 13.2k| if (igraph_i_attribute_table) {
------------------
| Branch (852:9): [True: 13.2k, False: 0]
------------------
853| 13.2k| return igraph_i_attribute_table->get_bool_vertex_attr(graph, name, vs, value);
854| 13.2k| } else {
855| 0| return IGRAPH_SUCCESS;
856| 0| }
857| 13.2k|}
igraph_i_attribute_get_bool_edge_attr:
862| 17.5k| igraph_vector_bool_t *value) {
863| 17.5k| igraph_vector_bool_clear(value);
864| 17.5k| if (igraph_i_attribute_table) {
------------------
| Branch (864:9): [True: 17.5k, False: 0]
------------------
865| 17.5k| return igraph_i_attribute_table->get_bool_edge_attr(graph, name, es, value);
866| 17.5k| } else {
867| 0| return IGRAPH_SUCCESS;
868| 0| }
869| 17.5k|}
igraph_set_attribute_table:
895| 19.1k|igraph_set_attribute_table(const igraph_attribute_table_t * table) {
896| 19.1k| igraph_attribute_table_t *old = igraph_i_attribute_table;
897| 19.1k| igraph_i_attribute_table = (igraph_attribute_table_t*) table;
898| 19.1k| return old;
899| 19.1k|}
attributes.c:igraph_i_attribute_record_destroy_values:
185| 123k|static void igraph_i_attribute_record_destroy_values(igraph_attribute_record_t *attr) {
186| 123k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 123k| do { \
| | 925| 123k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 123k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 123k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 123k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 123k]
| | ------------------
------------------
187| |
188| 123k| if (attr->value.as_raw) {
------------------
| Branch (188:9): [True: 59.9k, False: 63.7k]
------------------
189| 59.9k| switch (attr->type) {
190| 11.3k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (190:13): [True: 11.3k, False: 48.6k]
------------------
191| 11.3k| igraph_vector_destroy(attr->value.as_vector);
192| 11.3k| break;
193| |
194| 44.1k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (194:13): [True: 44.1k, False: 15.8k]
------------------
195| 44.1k| igraph_strvector_destroy(attr->value.as_strvector);
196| 44.1k| break;
197| |
198| 4.55k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (198:13): [True: 4.55k, False: 55.4k]
------------------
199| 4.55k| igraph_vector_bool_destroy(attr->value.as_vector_bool);
200| 4.55k| break;
201| |
202| 0| default:
------------------
| Branch (202:13): [True: 0, False: 59.9k]
------------------
203| 0| break;
204| 59.9k| }
205| |
206| 59.9k| igraph_free(attr->value.as_raw);
207| 59.9k| attr->value.as_raw = NULL;
208| 59.9k| }
209| |
210| 123k| switch (attr->type) {
211| 11.3k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (211:9): [True: 11.3k, False: 112k]
------------------
212| 11.3k| attr->default_value.numeric = 0;
213| 11.3k| break;
214| |
215| 44.1k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (215:9): [True: 44.1k, False: 79.6k]
------------------
216| 44.1k| if (attr->default_value.string) {
------------------
| Branch (216:17): [True: 747, False: 43.3k]
------------------
217| 747| igraph_free(attr->default_value.string);
218| 747| attr->default_value.string = NULL;
219| 747| }
220| 44.1k| break;
221| |
222| 4.55k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (222:9): [True: 4.55k, False: 119k]
------------------
223| 4.55k| attr->default_value.boolean = 0;
224| 4.55k| break;
225| |
226| 63.7k| default:
------------------
| Branch (226:9): [True: 63.7k, False: 59.9k]
------------------
227| 63.7k| break;
228| 123k| }
229| |
230| 123k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
231| 123k|}
attributes.c:igraph_i_attribute_record_set_type:
506| 59.9k|) {
507| 59.9k| bool type_changed = attr->type != type;
508| |
509| 59.9k| if (type_changed || attr->value.as_raw != ptr) {
------------------
| Branch (509:9): [True: 59.9k, False: 0]
| Branch (509:25): [True: 0, False: 0]
------------------
510| 59.9k| igraph_i_attribute_record_destroy_values(attr);
511| 59.9k| attr->type = type;
512| 59.9k| attr->value.as_raw = ptr;
513| 59.9k| }
514| |
515| 59.9k| if (type_changed && type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (515:9): [True: 59.9k, False: 0]
| Branch (515:25): [True: 11.3k, False: 48.6k]
------------------
516| 11.3k| IGRAPH_ASSERT(
------------------
| | 924| 11.3k| do { \
| | 925| 11.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 11.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 11.3k]
| | ------------------
------------------
517| 11.3k| igraph_attribute_record_set_default_numeric(attr, IGRAPH_NAN) == IGRAPH_SUCCESS
518| 11.3k| );
519| 11.3k| }
520| 59.9k|}
attributes.c:igraph_i_attribute_record_list_init_item:
596| 37.9k|) {
597| 37.9k| IGRAPH_UNUSED(list);
------------------
| | 30| 37.9k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
598| | return igraph_attribute_record_init(item, NULL, IGRAPH_ATTRIBUTE_UNSPECIFIED);
599| 37.9k|}
attributes.c:igraph_i_attribute_record_list_copy_item:
603| 2.27k|) {
604| 2.27k| return igraph_attribute_record_init_copy(dest, source);
605| 2.27k|}
attributes.c:igraph_i_attribute_record_list_destroy_item:
607| 59.5k|static void igraph_i_attribute_record_list_destroy_item(igraph_attribute_record_t* item) {
608| 59.5k| igraph_attribute_record_destroy(item);
609| 59.5k|}
igraph_i_property_cache_init:
32| 15.6k|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) {
33| 15.6k| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32);
------------------
| | 68| 15.6k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
34| |
35| 15.6k| memset(cache->value, 0, sizeof(cache->value));
36| 15.6k| cache->known = 0;
37| 15.6k| return IGRAPH_SUCCESS;
38| 15.6k|}
igraph_i_property_cache_destroy:
53| 15.6k|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) {
54| 15.6k| IGRAPH_UNUSED(cache);
------------------
| | 30| 15.6k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
55| | /* Nothing to do */
56| 15.6k|}
igraph_i_property_cache_invalidate_conditionally:
182| 46.8k|) {
183| 46.8k| uint32_t invalidate = ~keep_always;
184| 46.8k| uint32_t mask;
185| 46.8k| uint32_t maybe_keep;
186| 46.8k| igraph_bool_t cached_value;
187| |
188| 46.8k| assert(graph->cache != NULL);
------------------
| Branch (188:5): [True: 0, False: 46.8k]
| Branch (188:5): [True: 46.8k, 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| 46.8k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true);
197| |
198| 46.8k| if (maybe_keep) {
------------------
| Branch (198:9): [True: 0, False: 46.8k]
------------------
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| 46.8k| graph->cache->known &= ~invalidate;
216| 46.8k|}
cattributes.c:igraph_i_cattribute_init:
195| 15.6k|) {
196| 15.6k| igraph_i_cattributes_t *nattr;
197| |
198| 15.6k| nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t);
------------------
| | 33| 15.6k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 31.2k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 15.6k, Folded]
| | | | ------------------
| | ------------------
------------------
199| 15.6k| IGRAPH_CHECK_OOM(nattr, "Insufficient memory to allocate attribute storage.");
------------------
| | 709| 15.6k| do { \
| | 710| 15.6k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.6k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 15.6k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 15.6k]
| | ------------------
------------------
200| 15.6k| IGRAPH_FINALLY(igraph_free, nattr);
------------------
| | 603| 15.6k| do { \
| | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | 607| 15.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.6k]
| | ------------------
| | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.6k]
| | ------------------
------------------
201| |
202| 15.6k| if (attr) {
------------------
| Branch (202:9): [True: 9.49k, False: 6.11k]
------------------
203| 9.49k| IGRAPH_CHECK(igraph_attribute_record_list_init_copy(&nattr->gal, attr));
------------------
| | 656| 9.49k| do { \
| | 657| 9.49k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 9.49k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 9.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.49k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.49k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 9.49k]
| | ------------------
------------------
204| 9.49k| } else {
205| 6.11k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->gal, 0));
------------------
| | 656| 6.11k| do { \
| | 657| 6.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.11k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.11k]
| | ------------------
------------------
206| 6.11k| }
207| 15.6k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->gal);
------------------
| | 603| 15.6k| do { \
| | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | 607| 15.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.6k]
| | ------------------
| | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.6k]
| | ------------------
------------------
208| |
209| 15.6k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->val, 0));
------------------
| | 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]
| | ------------------
------------------
210| 15.6k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->val);
------------------
| | 603| 15.6k| do { \
| | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | 607| 15.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.6k]
| | ------------------
| | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.6k]
| | ------------------
------------------
211| |
212| 15.6k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->eal, 0));
------------------
| | 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]
| | ------------------
------------------
213| 15.6k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->eal);
------------------
| | 603| 15.6k| do { \
| | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | 607| 15.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.6k]
| | ------------------
| | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.6k]
| | ------------------
------------------
214| |
215| 15.6k| graph->attr = nattr;
216| 15.6k| IGRAPH_FINALLY_CLEAN(4);
217| |
218| 15.6k| return IGRAPH_SUCCESS;
219| 15.6k|}
cattributes.c:igraph_i_cattribute_destroy:
221| 15.6k|static void igraph_i_cattribute_destroy(igraph_t *graph) {
222| 15.6k| igraph_i_cattributes_t *attr = graph->attr;
223| 15.6k| igraph_attribute_record_list_destroy(&attr->eal);
224| 15.6k| igraph_attribute_record_list_destroy(&attr->val);
225| 15.6k| igraph_attribute_record_list_destroy(&attr->gal);
226| | IGRAPH_FREE(graph->attr); /* sets to NULL */
------------------
| | 36| 15.6k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
227| 15.6k|}
cattributes.c:igraph_i_cattribute_add_vertices:
373| 31.2k|) {
374| 31.2k| igraph_i_cattributes_t *attr = graph->attr;
375| 31.2k| return igraph_i_cattribute_add_vertices_or_edges(&attr->val, igraph_vcount(graph), nv, nattr);
376| 31.2k|}
cattributes.c:igraph_i_cattribute_add_vertices_or_edges:
344| 46.8k|) {
345| 46.8k| igraph_int_t origlen = newlen - nv;
346| 46.8k| igraph_error_t err = igraph_i_cattribute_add_vertices_or_edges_inner(
347| 46.8k| val, newlen, nv, nattr
348| 46.8k| );
349| |
350| 46.8k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (350:9): [True: 0, False: 46.8k]
------------------
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| 46.8k| return err;
368| 46.8k|}
cattributes.c:igraph_i_cattribute_add_vertices_or_edges_inner:
269| 46.8k|) {
270| 46.8k| igraph_int_t length;
271| 46.8k| igraph_int_t nattrno = nattr == NULL ? 0 : igraph_attribute_record_list_size(nattr);
------------------
| Branch (271:28): [True: 21.3k, False: 25.4k]
------------------
272| 46.8k| igraph_int_t origlen = newlen - nv;
273| |
274| 46.8k| IGRAPH_ASSERT(origlen >= 0);
------------------
| | 924| 46.8k| do { \
| | 925| 46.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 46.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 46.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 46.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 46.8k]
| | ------------------
------------------
275| |
276| | /* Find all the attributes that are newly added, and create new value vectors
277| | * for them in the original graph */
278| 74.3k| for (igraph_int_t i = 0; i < nattrno; i++) {
------------------
| Branch (278:30): [True: 27.4k, False: 46.8k]
------------------
279| 27.4k| const igraph_attribute_record_t *nattr_entry = igraph_attribute_record_list_get_ptr(nattr, i);
280| 27.4k| const char *nname = nattr_entry->name;
281| 27.4k| IGRAPH_CHECK(igraph_i_cattribute_find_or_create(val, nname, nattr_entry->type, origlen, NULL));
------------------
| | 656| 27.4k| do { \
| | 657| 27.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.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| 27.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27.4k]
| | ------------------
------------------
282| 27.4k| }
283| |
284| | /* Now append the new values */
285| 46.8k| length = igraph_attribute_record_list_size(val);
286| 74.3k| for (igraph_int_t i = 0; i < length; i++) {
------------------
| Branch (286:30): [True: 27.4k, False: 46.8k]
------------------
287| 27.4k| igraph_attribute_record_t *oldrec = igraph_attribute_record_list_get_ptr(val, i);
288| 27.4k| const igraph_attribute_record_t *newrec = nattr
------------------
| Branch (288:51): [True: 27.4k, False: 0]
------------------
289| 27.4k| ? igraph_i_cattribute_find_const(nattr, oldrec->name, oldrec->type)
290| 27.4k| : NULL;
291| |
292| 27.4k| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == origlen);
------------------
| | 924| 27.4k| do { \
| | 925| 27.4k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 27.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.4k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 27.4k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 27.4k]
| | ------------------
------------------
293| |
294| 27.4k| if (newrec) {
------------------
| Branch (294:13): [True: 27.4k, False: 0]
------------------
295| | /* This attribute is present in nattr */
296| 27.4k| switch (oldrec->type) {
297| 5.23k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (297:13): [True: 5.23k, False: 22.2k]
------------------
298| 5.23k| if (nv != igraph_vector_size(newrec->value.as_vector)) {
------------------
| Branch (298:21): [True: 0, False: 5.23k]
------------------
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.23k| IGRAPH_CHECK(igraph_vector_append(
------------------
| | 656| 5.23k| do { \
| | 657| 5.23k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.23k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.23k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.23k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.23k]
| | ------------------
------------------
302| 5.23k| oldrec->value.as_vector, newrec->value.as_vector
303| 5.23k| ));
304| 5.23k| break;
305| 20.3k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (305:13): [True: 20.3k, False: 7.13k]
------------------
306| 20.3k| if (nv != igraph_strvector_size(newrec->value.as_strvector)) {
------------------
| Branch (306:21): [True: 0, False: 20.3k]
------------------
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| 20.3k| IGRAPH_CHECK(igraph_strvector_append(
------------------
| | 656| 20.3k| do { \
| | 657| 20.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 20.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 20.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 20.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| 20.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 20.3k]
| | ------------------
------------------
310| 20.3k| oldrec->value.as_strvector, newrec->value.as_strvector
311| 20.3k| ));
312| 20.3k| break;
313| 20.3k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (313:13): [True: 1.90k, False: 25.5k]
------------------
314| 1.90k| if (nv != igraph_vector_bool_size(newrec->value.as_vector_bool)) {
------------------
| Branch (314:21): [True: 0, False: 1.90k]
------------------
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| 1.90k| IGRAPH_CHECK(igraph_vector_bool_append(
------------------
| | 656| 1.90k| do { \
| | 657| 1.90k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.90k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.90k]
| | ------------------
------------------
318| 1.90k| oldrec->value.as_vector_bool, newrec->value.as_vector_bool
319| 1.90k| ));
320| 1.90k| break;
321| 1.90k| default:
------------------
| Branch (321:13): [True: 0, False: 27.4k]
------------------
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| 27.4k| }
328| 27.4k| } 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| 27.4k| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == newlen);
------------------
| | 924| 27.4k| do { \
| | 925| 27.4k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 27.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.4k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 27.4k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 27.4k]
| | ------------------
------------------
335| 27.4k| }
336| |
337| 46.8k| return IGRAPH_SUCCESS;
338| 46.8k|}
cattributes.c:igraph_i_cattribute_find_const:
90| 27.4k|) {
91| 27.4k| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name);
92| 27.4k| const igraph_attribute_record_t *rec;
93| |
94| 27.4k| if (index >= 0) {
------------------
| Branch (94:9): [True: 27.4k, False: 0]
------------------
95| 27.4k| rec = igraph_attribute_record_list_get_ptr(attrs, index);
96| 27.4k| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) {
------------------
| Branch (96:13): [True: 0, False: 27.4k]
| Branch (96:53): [True: 27.4k, False: 0]
------------------
97| 27.4k| return rec;
98| 27.4k| }
99| 27.4k| }
100| |
101| 0| return NULL;
102| 27.4k|}
cattributes.c:igraph_i_cattribute_add_edges:
1463| 15.6k|) {
1464| 15.6k| igraph_int_t ne = igraph_vector_int_size(edges) / 2;
1465| 15.6k| igraph_i_cattributes_t *attr = graph->attr;
1466| 15.6k| return igraph_i_cattribute_add_vertices_or_edges(&attr->eal, igraph_ecount(graph), ne, nattr);
1467| 15.6k|}
cattributes.c:igraph_i_cattribute_get_info:
1498| 9.53k| igraph_vector_int_t *etypes) {
1499| |
1500| 9.53k| igraph_strvector_t *names[3] = { gnames, vnames, enames };
1501| 9.53k| igraph_vector_int_t *types[3] = { gtypes, vtypes, etypes };
1502| 9.53k| igraph_i_cattributes_t *at = graph->attr;
1503| 9.53k| igraph_attribute_record_list_t *attr[3] = { &at->gal, &at->val, &at->eal };
1504| |
1505| 38.1k| for (igraph_int_t i = 0; i < 3; i++) {
------------------
| Branch (1505:30): [True: 28.6k, False: 9.53k]
------------------
1506| 28.6k| igraph_strvector_t *n = names[i];
1507| 28.6k| igraph_vector_int_t *t = types[i];
1508| 28.6k| const igraph_attribute_record_list_t *al = attr[i];
1509| 28.6k| igraph_int_t len = igraph_attribute_record_list_size(al);
1510| |
1511| 28.6k| if (n) {
------------------
| Branch (1511:13): [True: 28.6k, False: 0]
------------------
1512| 28.6k| IGRAPH_CHECK(igraph_strvector_resize(n, len));
------------------
| | 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]
| | ------------------
------------------
1513| 28.6k| }
1514| 28.6k| if (t) {
------------------
| Branch (1514:13): [True: 28.6k, False: 0]
------------------
1515| 28.6k| IGRAPH_CHECK(igraph_vector_int_resize(t, len));
------------------
| | 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]
| | ------------------
------------------
1516| 28.6k| }
1517| |
1518| 53.8k| for (igraph_int_t j = 0; j < len; j++) {
------------------
| Branch (1518:34): [True: 25.2k, False: 28.6k]
------------------
1519| 25.2k| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(al, j);
1520| 25.2k| const char *name = rec->name;
1521| 25.2k| igraph_attribute_type_t type = rec->type;
1522| 25.2k| if (n) {
------------------
| Branch (1522:17): [True: 25.2k, False: 0]
------------------
1523| 25.2k| IGRAPH_CHECK(igraph_strvector_set(n, j, name));
------------------
| | 656| 25.2k| do { \
| | 657| 25.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 25.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 25.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 25.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| 25.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 25.2k]
| | ------------------
------------------
1524| 25.2k| }
1525| 25.2k| if (t) {
------------------
| Branch (1525:17): [True: 25.2k, False: 0]
------------------
1526| 25.2k| VECTOR(*t)[j] = type;
------------------
| | 60| 25.2k|#define VECTOR(v) ((v).stor_begin)
------------------
1527| 25.2k| }
1528| 25.2k| }
1529| 28.6k| }
1530| |
1531| 9.53k| return IGRAPH_SUCCESS;
1532| 9.53k|}
cattributes.c:igraph_i_cattribute_has_attr:
1536| 200k| const char *name) {
1537| 200k| const igraph_i_cattributes_t *at = graph->attr;
1538| 200k| switch (type) {
1539| 0| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (1539:5): [True: 0, False: 200k]
------------------
1540| 0| return igraph_i_cattribute_find_index(&at->gal, name) >= 0;
1541| 123k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (1541:5): [True: 123k, False: 76.2k]
------------------
1542| 123k| return igraph_i_cattribute_find_index(&at->val, name) >= 0;
1543| 76.2k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (1543:5): [True: 76.2k, False: 123k]
------------------
1544| 76.2k| return igraph_i_cattribute_find_index(&at->eal, name) >= 0;
1545| 0| default:
------------------
| Branch (1545:5): [True: 0, False: 200k]
------------------
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| 200k| }
1549| |
1550| 0| return false;
1551| 200k|}
cattributes.c:igraph_i_cattribute_get_type:
1556| 2.70k| const char *name) {
1557| 2.70k| igraph_attribute_record_t *rec;
1558| 2.70k| igraph_i_cattributes_t *at = graph->attr;
1559| 2.70k| igraph_attribute_record_list_t *al;
1560| |
1561| 2.70k| switch (elemtype) {
1562| 0| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (1562:5): [True: 0, False: 2.70k]
------------------
1563| 0| al = &at->gal;
1564| 0| break;
1565| 1.62k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (1565:5): [True: 1.62k, False: 1.07k]
------------------
1566| 1.62k| al = &at->val;
1567| 1.62k| break;
1568| 1.07k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (1568:5): [True: 1.07k, False: 1.62k]
------------------
1569| 1.07k| al = &at->eal;
1570| 1.07k| break;
1571| 0| default:
------------------
| Branch (1571:5): [True: 0, False: 2.70k]
------------------
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.70k| }
1575| |
1576| 2.70k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(al, name, IGRAPH_ATTRIBUTE_UNSPECIFIED, &rec));
------------------
| | 656| 2.70k| do { \
| | 657| 2.70k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.70k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.70k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.70k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.70k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.70k]
| | ------------------
------------------
1577| 2.70k| *type = rec->type;
1578| |
1579| 2.70k| return IGRAPH_SUCCESS;
1580| 2.70k|}
cattributes.c:igraph_i_cattribute_find_or_return:
113| 1.56M|) {
114| 1.56M| igraph_attribute_record_t *rec;
115| |
116| 1.56M| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED);
117| 1.56M| if (!rec) {
------------------
| Branch (117:9): [True: 8, False: 1.56M]
------------------
118| 8| IGRAPH_ERRORF("Attribute '%s' does not exist.", IGRAPH_EINVAL, name);
------------------
| | 464| 8| do { \
| | 465| 8| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 8| igraph_errno, __VA_ARGS__) ; \
| | 467| 8| return igraph_errno; \
| | 468| 8| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
119| 8| }
120| |
121| 1.56M| if (type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (121:9): [True: 1.56M, False: 2.70k]
------------------
122| 1.56M| IGRAPH_CHECK(igraph_attribute_record_check_type(rec, type));
------------------
| | 656| 1.56M| do { \
| | 657| 1.56M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.56M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.56M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 1.56M]
| | | | ------------------
| | ------------------
| | 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.56M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.56M]
| | ------------------
------------------
123| 1.56M| }
124| |
125| 1.56M| if (ptr) {
------------------
| Branch (125:9): [True: 1.56M, False: 0]
------------------
126| 1.56M| *ptr = rec;
127| 1.56M| }
128| |
129| 1.56M| return IGRAPH_SUCCESS;
130| 1.56M|}
cattributes.c:igraph_i_cattribute_get_numeric_graph_attr:
1584| 326|) {
1585| 326| igraph_i_cattributes_t *attr = graph->attr;
1586| 326| igraph_attribute_record_list_t *gal = &attr->gal;
1587| 326| igraph_attribute_record_t *rec;
1588| |
1589| 326| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_NUMERIC, &rec));
------------------
| | 656| 326| do { \
| | 657| 326| igraph_error_t igraph_i_ret = (expr); \
| | 658| 326| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 326| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 326]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 326| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 326]
| | ------------------
------------------
1590| 326| IGRAPH_CHECK(igraph_vector_push_back(value, VECTOR(*rec->value.as_vector)[0]));
------------------
| | 656| 326| do { \
| | 657| 326| igraph_error_t igraph_i_ret = (expr); \
| | 658| 326| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 326| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 326]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 326| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 326]
| | ------------------
------------------
1591| |
1592| 326| return IGRAPH_SUCCESS;
1593| 326|}
cattributes.c:igraph_i_cattribute_get_string_graph_attr:
1610| 1.68k|) {
1611| 1.68k| igraph_i_cattributes_t *attr = graph->attr;
1612| 1.68k| igraph_attribute_record_list_t *gal = &attr->gal;
1613| 1.68k| igraph_attribute_record_t *rec;
1614| |
1615| 1.68k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 656| 1.68k| do { \
| | 657| 1.68k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.68k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.68k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.68k]
| | ------------------
------------------
1616| 1.68k| IGRAPH_CHECK(igraph_strvector_push_back(value, igraph_strvector_get(rec->value.as_strvector, 0)));
------------------
| | 656| 1.68k| do { \
| | 657| 1.68k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.68k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.68k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.68k]
| | ------------------
------------------
1617| |
1618| 1.68k| return IGRAPH_SUCCESS;
1619| 1.68k|}
cattributes.c:igraph_i_cattribute_get_bool_graph_attr:
1597| 408|) {
1598| 408| igraph_i_cattributes_t *attr = graph->attr;
1599| 408| igraph_attribute_record_list_t *gal = &attr->gal;
1600| 408| igraph_attribute_record_t *rec;
1601| |
1602| 408| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 408| do { \
| | 657| 408| igraph_error_t igraph_i_ret = (expr); \
| | 658| 408| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 408| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 408]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 408| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 408]
| | ------------------
------------------
1603| 408| IGRAPH_CHECK(igraph_vector_bool_push_back(value, VECTOR(*rec->value.as_vector_bool)[0]));
------------------
| | 656| 408| do { \
| | 657| 408| igraph_error_t igraph_i_ret = (expr); \
| | 658| 408| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 408| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 408]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 408| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 408]
| | ------------------
------------------
1604| |
1605| 408| return IGRAPH_SUCCESS;
1606| 408|}
cattributes.c:igraph_i_cattribute_get_numeric_vertex_attr:
1624| 14.2k| igraph_vector_t *value) {
1625| 14.2k| igraph_i_cattributes_t *attr = graph->attr;
1626| 14.2k| igraph_attribute_record_list_t *val = &attr->val;
1627| 14.2k| igraph_attribute_record_t *rec;
1628| 14.2k| const igraph_vector_t *num;
1629| |
1630| 14.2k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_NUMERIC, &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]
| | ------------------
------------------
1631| |
1632| 14.2k| num = rec->value.as_vector;
1633| 14.2k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1633:9): [True: 69, False: 14.2k]
------------------
1634| 69| IGRAPH_CHECK(igraph_vector_append(value, num));
------------------
| | 656| 69| do { \
| | 657| 69| igraph_error_t igraph_i_ret = (expr); \
| | 658| 69| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 69| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 69]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 69| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 69]
| | ------------------
------------------
1635| 14.2k| } else {
1636| 14.2k| igraph_vit_t it;
1637| 14.2k| igraph_int_t i = igraph_vector_size(value);
1638| 14.2k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 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]
| | ------------------
------------------
1639| 14.2k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 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]
| | ------------------
------------------
1640| 14.2k| IGRAPH_CHECK(igraph_vector_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 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]
| | ------------------
------------------
1641| 28.4k| for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 179| 28.4k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end)
------------------
for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 167| 14.2k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1641:16): [True: 14.2k, False: 14.2k]
------------------
1642| 14.2k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 14.2k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 14.2k, False: 0]
| | ------------------
| | 215| 14.2k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1643| 14.2k| VECTOR(*value)[i] = VECTOR(*num)[v];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*num)[v];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
1644| 14.2k| }
1645| 14.2k| igraph_vit_destroy(&it);
1646| 14.2k| IGRAPH_FINALLY_CLEAN(1);
1647| 14.2k| }
1648| |
1649| 14.2k| return IGRAPH_SUCCESS;
1650| 14.2k|}
cattributes.c:igraph_i_cattribute_get_string_vertex_attr:
1686| 97.9k| igraph_strvector_t *value) {
1687| 97.9k| igraph_i_cattributes_t *attr = graph->attr;
1688| 97.9k| igraph_attribute_record_list_t *val = &attr->val;
1689| 97.9k| igraph_attribute_record_t *rec;
1690| 97.9k| const igraph_strvector_t *str;
1691| |
1692| 97.9k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 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]
| | ------------------
------------------
1693| |
1694| 97.9k| str = rec->value.as_strvector;
1695| 97.9k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1695:9): [True: 1.25k, False: 96.6k]
------------------
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| 96.6k| } else {
1699| 96.6k| igraph_vit_t it;
1700| 96.6k| igraph_int_t i = igraph_strvector_size(value);
1701| 96.6k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 656| 96.6k| do { \
| | 657| 96.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 96.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 96.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 96.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| 96.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 96.6k]
| | ------------------
------------------
1702| 96.6k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 603| 96.6k| do { \
| | 604| 96.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 96.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 96.6k| * incorrect destructor function with the pointer */ \
| | 607| 96.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 96.6k]
| | ------------------
| | 608| 96.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 96.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 96.6k]
| | ------------------
------------------
1703| 96.6k| IGRAPH_CHECK(igraph_strvector_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 656| 96.6k| do { \
| | 657| 96.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 96.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 96.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 96.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| 96.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 96.6k]
| | ------------------
------------------
1704| 193k| for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 179| 193k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end)
------------------
for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 167| 96.6k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1704:16): [True: 96.6k, False: 96.6k]
------------------
1705| 96.6k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 96.6k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 96.6k, False: 0]
| | ------------------
| | 215| 96.6k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1706| 96.6k| IGRAPH_CHECK(igraph_strvector_set(value, i, igraph_strvector_get(str, v)));
------------------
| | 656| 96.6k| do { \
| | 657| 96.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 96.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 96.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 96.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| 96.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 96.6k]
| | ------------------
------------------
1707| 96.6k| }
1708| 96.6k| igraph_vit_destroy(&it);
1709| 96.6k| IGRAPH_FINALLY_CLEAN(1);
1710| 96.6k| }
1711| |
1712| 97.9k| return IGRAPH_SUCCESS;
1713| 97.9k|}
cattributes.c:igraph_i_cattribute_get_bool_vertex_attr:
1655| 13.2k| igraph_vector_bool_t *value) {
1656| 13.2k| igraph_i_cattributes_t *attr = graph->attr;
1657| 13.2k| igraph_attribute_record_list_t *val = &attr->val;
1658| 13.2k| igraph_attribute_record_t *rec;
1659| 13.2k| const igraph_vector_bool_t *log;
1660| |
1661| 13.2k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 13.2k| do { \
| | 657| 13.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.2k]
| | ------------------
------------------
1662| |
1663| 13.2k| log = rec->value.as_vector_bool;
1664| 13.2k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1664:9): [True: 27, False: 13.2k]
------------------
1665| 27| IGRAPH_CHECK(igraph_vector_bool_append(value, log));
------------------
| | 656| 27| do { \
| | 657| 27| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27]
| | ------------------
------------------
1666| 13.2k| } else {
1667| 13.2k| igraph_vit_t it;
1668| 13.2k| igraph_int_t i = igraph_vector_bool_size(value);
1669| 13.2k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 656| 13.2k| do { \
| | 657| 13.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.2k]
| | ------------------
------------------
1670| 13.2k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 603| 13.2k| do { \
| | 604| 13.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 13.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 13.2k| * incorrect destructor function with the pointer */ \
| | 607| 13.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 13.2k]
| | ------------------
| | 608| 13.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 13.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 13.2k]
| | ------------------
------------------
1671| 13.2k| IGRAPH_CHECK(igraph_vector_bool_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 656| 13.2k| do { \
| | 657| 13.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.2k]
| | ------------------
------------------
1672| 26.4k| for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 179| 26.4k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end)
------------------
for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 167| 13.2k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1672:16): [True: 13.2k, False: 13.2k]
------------------
1673| 13.2k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 13.2k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 13.2k, False: 0]
| | ------------------
| | 215| 13.2k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1674| 13.2k| VECTOR(*value)[i] = VECTOR(*log)[v];
------------------
| | 60| 13.2k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*log)[v];
------------------
| | 60| 13.2k|#define VECTOR(v) ((v).stor_begin)
------------------
1675| 13.2k| }
1676| 13.2k| igraph_vit_destroy(&it);
1677| 13.2k| IGRAPH_FINALLY_CLEAN(1);
1678| 13.2k| }
1679| |
1680| 13.2k| return IGRAPH_SUCCESS;
1681| 13.2k|}
cattributes.c:igraph_i_cattribute_get_numeric_edge_attr:
1717| 375k|) {
1718| 375k| igraph_i_cattributes_t *attr = graph->attr;
1719| 375k| igraph_attribute_record_list_t *eal = &attr->eal;
1720| 375k| igraph_attribute_record_t *rec;
1721| 375k| const igraph_vector_t *num;
1722| |
1723| 375k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_NUMERIC, &rec));
------------------
| | 656| 375k| do { \
| | 657| 375k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 375k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 375k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 375k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 375k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 375k]
| | ------------------
------------------
1724| |
1725| 375k| num = rec->value.as_vector;
1726| 375k| if (igraph_es_is_all(&es)) {
------------------
| Branch (1726:9): [True: 538, False: 374k]
------------------
1727| 538| IGRAPH_CHECK(igraph_vector_append(value, num));
------------------
| | 656| 538| do { \
| | 657| 538| igraph_error_t igraph_i_ret = (expr); \
| | 658| 538| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 538| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 538]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 538| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 538]
| | ------------------
------------------
1728| 374k| } else {
1729| 374k| igraph_eit_t it;
1730| 374k| igraph_int_t i = igraph_vector_size(value);
1731| 374k| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 656| 374k| do { \
| | 657| 374k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 374k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 374k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 374k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 374k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 374k]
| | ------------------
------------------
1732| 374k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 374k| do { \
| | 604| 374k| /* the following branch makes the compiler check the compatibility of \
| | 605| 374k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 374k| * incorrect destructor function with the pointer */ \
| | 607| 374k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 374k]
| | ------------------
| | 608| 374k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 374k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 374k]
| | ------------------
------------------
1733| 374k| IGRAPH_CHECK(igraph_vector_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 656| 374k| do { \
| | 657| 374k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 374k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 374k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 374k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 374k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 374k]
| | ------------------
------------------
1734| 749k| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 749k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 374k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1734:16): [True: 374k, False: 374k]
------------------
1735| 374k| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 374k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 374k, False: 0]
| | ------------------
| | 406| 374k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1736| 374k| VECTOR(*value)[i] = VECTOR(*num)[e];
------------------
| | 60| 374k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*num)[e];
------------------
| | 60| 374k|#define VECTOR(v) ((v).stor_begin)
------------------
1737| 374k| }
1738| 374k| igraph_eit_destroy(&it);
1739| 374k| IGRAPH_FINALLY_CLEAN(1);
1740| 374k| }
1741| |
1742| 375k| return IGRAPH_SUCCESS;
1743| 375k|}
cattributes.c:igraph_i_cattribute_get_string_edge_attr:
1748| 1.04M|) {
1749| 1.04M| igraph_i_cattributes_t *attr = graph->attr;
1750| 1.04M| igraph_attribute_record_list_t *eal = &attr->eal;
1751| 1.04M| igraph_attribute_record_t *rec;
1752| 1.04M| const igraph_strvector_t *str;
1753| |
1754| 1.04M| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 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]
| | ------------------
------------------
1755| |
1756| 1.04M| str = rec->value.as_strvector;
1757| 1.04M| if (igraph_es_is_all(&es)) {
------------------
| Branch (1757:9): [True: 49, False: 1.04M]
------------------
1758| 49| IGRAPH_CHECK(igraph_strvector_append(value, str));
------------------
| | 656| 49| do { \
| | 657| 49| igraph_error_t igraph_i_ret = (expr); \
| | 658| 49| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 49| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 49| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 49]
| | ------------------
------------------
1759| 1.04M| } else {
1760| 1.04M| igraph_eit_t it;
1761| 1.04M| igraph_int_t i = igraph_strvector_size(value);
1762| 1.04M| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 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]
| | ------------------
------------------
1763| 1.04M| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 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]
| | ------------------
------------------
1764| 1.04M| IGRAPH_CHECK(igraph_strvector_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 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]
| | ------------------
------------------
1765| 2.09M| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 2.09M|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 1.04M|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1765:16): [True: 1.04M, False: 1.04M]
------------------
1766| 1.04M| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 1.04M| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 1.04M, False: 0]
| | ------------------
| | 406| 1.04M| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1767| 1.04M| IGRAPH_CHECK(igraph_strvector_set(value, i, igraph_strvector_get(str, e)));
------------------
| | 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]
| | ------------------
------------------
1768| 1.04M| }
1769| 1.04M| igraph_eit_destroy(&it);
1770| 1.04M| IGRAPH_FINALLY_CLEAN(1);
1771| 1.04M| }
1772| |
1773| 1.04M| return IGRAPH_SUCCESS;
1774| 1.04M|}
cattributes.c:igraph_i_cattribute_get_bool_edge_attr:
1779| 17.5k|) {
1780| 17.5k| igraph_i_cattributes_t *attr = graph->attr;
1781| 17.5k| igraph_attribute_record_list_t *eal = &attr->eal;
1782| 17.5k| igraph_attribute_record_t *rec;
1783| 17.5k| const igraph_vector_bool_t *log;
1784| |
1785| 17.5k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 17.5k| do { \
| | 657| 17.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 9, False: 17.5k]
| | | | ------------------
| | ------------------
| | 659| 9| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 9| do { \
| | | | 427| 9| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 9| return igraph_errno ; \
| | | | 429| 9| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 9| } \
| | 661| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
1786| |
1787| 17.5k| log = rec->value.as_vector_bool;
1788| 17.5k| if (igraph_es_is_all(&es)) {
------------------
| Branch (1788:9): [True: 17, False: 17.4k]
------------------
1789| 17| IGRAPH_CHECK(igraph_vector_bool_append(value, log));
------------------
| | 656| 17| do { \
| | 657| 17| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17]
| | ------------------
------------------
1790| 17.4k| } else {
1791| 17.4k| igraph_eit_t it;
1792| 17.4k| igraph_int_t i = igraph_vector_bool_size(value);
1793| 17.4k| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 656| 17.4k| do { \
| | 657| 17.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.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| 17.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.4k]
| | ------------------
------------------
1794| 17.4k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 17.4k| do { \
| | 604| 17.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.4k| * incorrect destructor function with the pointer */ \
| | 607| 17.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.4k]
| | ------------------
| | 608| 17.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.4k]
| | ------------------
------------------
1795| 17.4k| IGRAPH_CHECK(igraph_vector_bool_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 656| 17.4k| do { \
| | 657| 17.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.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| 17.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.4k]
| | ------------------
------------------
1796| 34.9k| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 34.9k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 17.4k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1796:16): [True: 17.4k, False: 17.4k]
------------------
1797| 17.4k| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 17.4k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 17.4k, False: 0]
| | ------------------
| | 406| 17.4k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1798| 17.4k| VECTOR(*value)[i] = VECTOR(*log)[e];
------------------
| | 60| 17.4k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*log)[e];
------------------
| | 60| 17.4k|#define VECTOR(v) ((v).stor_begin)
------------------
1799| 17.4k| }
1800| 17.4k| igraph_eit_destroy(&it);
1801| 17.4k| IGRAPH_FINALLY_CLEAN(1);
1802| 17.4k| }
1803| |
1804| 17.5k| return IGRAPH_SUCCESS;
1805| 17.5k|}
cattributes.c:igraph_i_cattribute_find:
69| 1.59M|) {
70| 1.59M| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name);
71| 1.59M| igraph_attribute_record_t *rec;
72| |
73| 1.59M| if (index >= 0) {
------------------
| Branch (73:9): [True: 1.56M, False: 27.4k]
------------------
74| 1.56M| rec = igraph_attribute_record_list_get_ptr(attrs, index);
75| 1.56M| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) {
------------------
| Branch (75:13): [True: 1.56M, False: 0]
| Branch (75:53): [True: 0, False: 0]
------------------
76| 1.56M| return rec;
77| 1.56M| }
78| 1.56M| }
79| |
80| 27.4k| return NULL;
81| 1.59M|}
cattributes.c:igraph_i_cattribute_find_or_create:
147| 27.4k|) {
148| 27.4k| igraph_attribute_record_t *rec;
149| |
150| 27.4k| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED);
151| 27.4k| if (rec) {
------------------
| Branch (151:9): [True: 0, False: 27.4k]
------------------
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| 27.4k| } else {
156| 27.4k| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(attrs, &rec));
------------------
| | 656| 27.4k| do { \
| | 657| 27.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.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| 27.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27.4k]
| | ------------------
------------------
157| 27.4k| IGRAPH_CHECK(igraph_attribute_record_set_name(rec, name));
------------------
| | 656| 27.4k| do { \
| | 657| 27.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.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| 27.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27.4k]
| | ------------------
------------------
158| 27.4k| IGRAPH_CHECK(igraph_attribute_record_set_type(rec, type));
------------------
| | 656| 27.4k| do { \
| | 657| 27.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.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| 27.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27.4k]
| | ------------------
------------------
159| 27.4k| }
160| |
161| 27.4k| if (length > 0 && igraph_attribute_record_size(rec) < length) {
------------------
| Branch (161:9): [True: 0, False: 27.4k]
| 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| 27.4k| if (ptr) {
------------------
| Branch (165:9): [True: 0, False: 27.4k]
------------------
166| 0| *ptr = rec;
167| 0| }
168| |
169| 27.4k| return IGRAPH_SUCCESS;
170| 27.4k|}
cattributes.c:igraph_i_cattribute_find_index:
49| 1.82M|) {
50| 1.82M| igraph_int_t n = igraph_attribute_record_list_size(attrs);
51| 3.34M| for (igraph_int_t i = 0; i < n; i++) {
------------------
| Branch (51:30): [True: 3.11M, False: 225k]
------------------
52| 3.11M| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrs, i);
53| 3.11M| if (!strcmp(rec->name, name)) {
------------------
| Branch (53:13): [True: 1.59M, False: 1.52M]
------------------
54| 1.59M| return i;
55| 1.59M| }
56| 3.11M| }
57| 225k| return -1;
58| 1.82M|}
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| 124k|igraph_vs_t igraph_vss_1(igraph_int_t vid) {
293| 124k| igraph_vs_t onevs;
294| 124k| onevs.type = IGRAPH_VS_1;
295| 124k| onevs.data.vid = vid;
296| 124k| return onevs;
297| 124k|}
igraph_vs_is_all:
544| 125k|igraph_bool_t igraph_vs_is_all(const igraph_vs_t *vs) {
545| 125k| return vs->type == IGRAPH_VS_ALL;
546| 125k|}
igraph_vit_create:
712| 124k|igraph_error_t igraph_vit_create(const igraph_t *graph, igraph_vs_t vs, igraph_vit_t *vit) {
713| 124k| igraph_vector_int_t vec;
714| 124k| igraph_vector_int_t *vec_int;
715| 124k| igraph_bool_t *seen;
716| 124k| igraph_int_t i, j, n;
717| 124k| igraph_int_t vec_len;
718| |
719| 124k| switch (vs.type) {
720| 0| case IGRAPH_VS_ALL:
------------------
| Branch (720:5): [True: 0, False: 124k]
------------------
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: 124k]
------------------
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: 124k]
------------------
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: 124k]
------------------
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| 124k| case IGRAPH_VS_1:
------------------
| Branch (796:5): [True: 124k, False: 0]
------------------
797| 124k| vit->type = IGRAPH_VIT_RANGE;
798| 124k| vit->pos = vs.data.vid;
799| 124k| vit->start = vs.data.vid;
800| 124k| vit->end = vs.data.vid + 1;
801| 124k| if (vit->pos >= igraph_vcount(graph)) {
------------------
| Branch (801:13): [True: 0, False: 124k]
------------------
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| 124k| break;
805| 124k| case IGRAPH_VS_VECTORPTR:
------------------
| Branch (805:5): [True: 0, False: 124k]
------------------
806| 0| case IGRAPH_VS_VECTOR:
------------------
| Branch (806:5): [True: 0, False: 124k]
------------------
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: 124k]
------------------
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: 124k]
------------------
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| 124k| }
837| 124k| return IGRAPH_SUCCESS;
838| 124k|}
igraph_vit_destroy:
853| 124k|void igraph_vit_destroy(const igraph_vit_t *vit) {
854| 124k| switch (vit->type) {
855| 124k| case IGRAPH_VIT_RANGE:
------------------
| Branch (855:5): [True: 124k, False: 0]
------------------
856| 124k| case IGRAPH_VIT_VECTORPTR:
------------------
| Branch (856:5): [True: 0, False: 124k]
------------------
857| 124k| break;
858| 0| case IGRAPH_VIT_VECTOR:
------------------
| Branch (858:5): [True: 0, False: 124k]
------------------
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: 124k]
------------------
863| | /* IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */
864| 0| break;
865| 124k| }
866| 124k|}
igraph_es_all:
921| 16.5k| igraph_edgeorder_type_t order) {
922| 16.5k| switch (order) {
923| 10.1k| case IGRAPH_EDGEORDER_ID:
------------------
| Branch (923:5): [True: 10.1k, False: 6.35k]
------------------
924| 10.1k| es->type = IGRAPH_ES_ALL;
925| 10.1k| break;
926| 6.35k| case IGRAPH_EDGEORDER_FROM:
------------------
| Branch (926:5): [True: 6.35k, False: 10.1k]
------------------
927| 6.35k| es->type = IGRAPH_ES_ALLFROM;
928| 6.35k| break;
929| 0| case IGRAPH_EDGEORDER_TO:
------------------
| Branch (929:5): [True: 0, False: 16.5k]
------------------
930| 0| es->type = IGRAPH_ES_ALLTO;
931| 0| break;
932| 0| default:
------------------
| Branch (932:5): [True: 0, False: 16.5k]
------------------
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| 16.5k| }
936| 16.5k| return IGRAPH_SUCCESS;
937| 16.5k|}
igraph_ess_all:
953| 13.3k|igraph_es_t igraph_ess_all(igraph_edgeorder_type_t order) {
954| 13.3k| igraph_es_t es;
955| 13.3k| igraph_es_all(&es, order); /* cannot fail */
956| 13.3k| return es;
957| 13.3k|}
igraph_ess_1:
1058| 1.43M|igraph_es_t igraph_ess_1(igraph_int_t eid) {
1059| 1.43M| igraph_es_t es;
1060| 1.43M| es.type = IGRAPH_ES_1;
1061| 1.43M| es.data.eid = eid;
1062| 1.43M| return es;
1063| 1.43M|}
igraph_es_destroy:
1408| 3.17k|void igraph_es_destroy(igraph_es_t *es) {
1409| 3.17k| switch (es->type) {
1410| 3.17k| case IGRAPH_ES_ALL:
------------------
| Branch (1410:5): [True: 3.17k, False: 0]
------------------
1411| 3.17k| case IGRAPH_ES_ALLFROM:
------------------
| Branch (1411:5): [True: 0, False: 3.17k]
------------------
1412| 3.17k| case IGRAPH_ES_ALLTO:
------------------
| Branch (1412:5): [True: 0, False: 3.17k]
------------------
1413| 3.17k| case IGRAPH_ES_INCIDENT:
------------------
| Branch (1413:5): [True: 0, False: 3.17k]
------------------
1414| 3.17k| case IGRAPH_ES_NONE:
------------------
| Branch (1414:5): [True: 0, False: 3.17k]
------------------
1415| 3.17k| case IGRAPH_ES_1:
------------------
| Branch (1415:5): [True: 0, False: 3.17k]
------------------
1416| 3.17k| case IGRAPH_ES_VECTORPTR:
------------------
| Branch (1416:5): [True: 0, False: 3.17k]
------------------
1417| 3.17k| case IGRAPH_ES_RANGE:
------------------
| Branch (1417:5): [True: 0, False: 3.17k]
------------------
1418| 3.17k| case IGRAPH_ES_ALL_BETWEEN:
------------------
| Branch (1418:5): [True: 0, False: 3.17k]
------------------
1419| 3.17k| break;
1420| 0| case IGRAPH_ES_VECTOR:
------------------
| Branch (1420:5): [True: 0, False: 3.17k]
------------------
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.17k]
------------------
1425| 0| case IGRAPH_ES_PATH:
------------------
| Branch (1425:5): [True: 0, False: 3.17k]
------------------
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.17k]
------------------
1430| 0| break;
1431| 3.17k| }
1432| 3.17k|}
igraph_es_is_all:
1445| 1.43M|igraph_bool_t igraph_es_is_all(const igraph_es_t *es) {
1446| 1.43M| return es->type == IGRAPH_ES_ALL;
1447| 1.43M|}
igraph_eit_create:
1922| 1.45M|igraph_error_t igraph_eit_create(const igraph_t *graph, igraph_es_t es, igraph_eit_t *eit) {
1923| 1.45M| switch (es.type) {
1924| 9.53k| case IGRAPH_ES_ALL:
------------------
| Branch (1924:5): [True: 9.53k, False: 1.44M]
------------------
1925| 9.53k| eit->type = IGRAPH_EIT_RANGE;
1926| 9.53k| eit->pos = 0;
1927| 9.53k| eit->start = 0;
1928| 9.53k| eit->end = igraph_ecount(graph);
1929| 9.53k| break;
1930| 6.35k| case IGRAPH_ES_ALLFROM:
------------------
| Branch (1930:5): [True: 6.35k, False: 1.44M]
------------------
1931| 6.35k| IGRAPH_CHECK(igraph_i_eit_create_allfromto(graph, eit, IGRAPH_OUT));
------------------
| | 656| 6.35k| do { \
| | 657| 6.35k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.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| 6.35k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.35k]
| | ------------------
------------------
1932| 6.35k| break;
1933| 6.35k| case IGRAPH_ES_ALLTO:
------------------
| Branch (1933:5): [True: 0, False: 1.45M]
------------------
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.45M]
------------------
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.45M]
------------------
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.43M| case IGRAPH_ES_1:
------------------
| Branch (1945:5): [True: 1.43M, False: 15.8k]
------------------
1946| 1.43M| eit->type = IGRAPH_EIT_RANGE;
1947| 1.43M| eit->pos = es.data.eid;
1948| 1.43M| eit->start = es.data.eid;
1949| 1.43M| eit->end = es.data.eid + 1;
1950| 1.43M| if (eit->pos >= igraph_ecount(graph)) {
------------------
| Branch (1950:13): [True: 0, False: 1.43M]
------------------
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.43M| break;
1954| 1.43M| case IGRAPH_ES_VECTOR:
------------------
| Branch (1954:5): [True: 0, False: 1.45M]
------------------
1955| 0| case IGRAPH_ES_VECTORPTR:
------------------
| Branch (1955:5): [True: 0, False: 1.45M]
------------------
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.45M]
------------------
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.45M]
------------------
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.45M]
------------------
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.45M]
------------------
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.45M]
------------------
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.45M| }
1995| 1.45M| return IGRAPH_SUCCESS;
1996| 1.45M|}
igraph_eit_destroy:
2008| 1.45M|void igraph_eit_destroy(const igraph_eit_t *eit) {
2009| 1.45M| switch (eit->type) {
2010| 1.44M| case IGRAPH_EIT_RANGE:
------------------
| Branch (2010:5): [True: 1.44M, False: 6.35k]
------------------
2011| 1.44M| case IGRAPH_EIT_VECTORPTR:
------------------
| Branch (2011:5): [True: 0, False: 1.45M]
------------------
2012| 1.44M| break;
2013| 6.35k| case IGRAPH_EIT_VECTOR:
------------------
| Branch (2013:5): [True: 6.35k, False: 1.44M]
------------------
2014| 6.35k| igraph_vector_int_destroy((igraph_vector_int_t*)eit->vec);
2015| 6.35k| igraph_free((igraph_vector_int_t*)eit->vec);
2016| 6.35k| break;
2017| 0| default:
------------------
| Branch (2017:5): [True: 0, False: 1.45M]
------------------
2018| | /* IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */
2019| 0| break;
2020| 1.45M| }
2021| 1.45M|}
iterators.c:igraph_i_eit_create_allfromto:
1696| 6.35k| igraph_neimode_t mode) {
1697| 6.35k| igraph_vector_int_t *vec;
1698| 6.35k| igraph_int_t no_of_nodes = igraph_vcount(graph);
1699| 6.35k| igraph_int_t no_of_edges = igraph_ecount(graph);
1700| |
1701| 6.35k| vec = IGRAPH_CALLOC(1, igraph_vector_int_t);
------------------
| | 33| 6.35k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 12.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: 6.35k, Folded]
| | | | ------------------
| | ------------------
------------------
1702| 6.35k| IGRAPH_CHECK_OOM(vec, "Cannot create edge iterator.");
------------------
| | 709| 6.35k| do { \
| | 710| 6.35k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 6.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.35k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 6.35k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 6.35k]
| | ------------------
------------------
1703| 6.35k| IGRAPH_FINALLY(igraph_free, vec);
------------------
| | 603| 6.35k| do { \
| | 604| 6.35k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.35k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.35k| * incorrect destructor function with the pointer */ \
| | 607| 6.35k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.35k]
| | ------------------
| | 608| 6.35k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.35k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.35k]
| | ------------------
------------------
1704| |
1705| 6.35k| IGRAPH_VECTOR_INT_INIT_FINALLY(vec, 0);
------------------
| | 119| 6.35k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 6.35k| do { \
| | | | 657| 6.35k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 6.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 6.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 6.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| 6.35k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 6.35k]
| | | | ------------------
| | ------------------
| | 120| 6.35k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 6.35k| do { \
| | | | 604| 6.35k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 6.35k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 6.35k| * incorrect destructor function with the pointer */ \
| | | | 607| 6.35k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 6.35k]
| | | | ------------------
| | | | 608| 6.35k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 6.35k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 6.35k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 6.35k]
| | ------------------
------------------
1706| 6.35k| IGRAPH_CHECK(igraph_vector_int_reserve(vec, no_of_edges));
------------------
| | 656| 6.35k| do { \
| | 657| 6.35k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.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| 6.35k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.35k]
| | ------------------
------------------
1707| |
1708| 6.35k| if (igraph_is_directed(graph)) {
------------------
| Branch (1708:9): [True: 266, False: 6.09k]
------------------
1709| 266| igraph_vector_int_t adj;
1710| 266| IGRAPH_VECTOR_INT_INIT_FINALLY(&adj, 0);
------------------
| | 119| 266| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 266| do { \
| | | | 657| 266| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 266| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 266| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 266]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 266| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 266]
| | | | ------------------
| | ------------------
| | 120| 266| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 266| do { \
| | | | 604| 266| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 266| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 266| * incorrect destructor function with the pointer */ \
| | | | 607| 266| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 266]
| | | | ------------------
| | | | 608| 266| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 266| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 266]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 266]
| | ------------------
------------------
1711| 2.73k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1711:34): [True: 2.47k, False: 266]
------------------
1712| 2.47k| IGRAPH_CHECK(igraph_incident(graph, &adj, i, mode, IGRAPH_LOOPS));
------------------
| | 656| 2.47k| do { \
| | 657| 2.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.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| 2.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.47k]
| | ------------------
------------------
1713| 2.47k| igraph_vector_int_append(vec, &adj); /* reserved */
1714| 2.47k| }
1715| 266| igraph_vector_int_destroy(&adj);
1716| 266| IGRAPH_FINALLY_CLEAN(1);
1717| 6.09k| } else {
1718| 6.09k| igraph_vector_int_t adj;
1719| 6.09k| igraph_bool_t *added;
1720| 6.09k| IGRAPH_VECTOR_INT_INIT_FINALLY(&adj, 0);
------------------
| | 119| 6.09k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 6.09k| do { \
| | | | 657| 6.09k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 6.09k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 6.09k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 6.09k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.09k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 6.09k]
| | | | ------------------
| | ------------------
| | 120| 6.09k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 6.09k| do { \
| | | | 604| 6.09k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 6.09k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 6.09k| * incorrect destructor function with the pointer */ \
| | | | 607| 6.09k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 6.09k]
| | | | ------------------
| | | | 608| 6.09k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 6.09k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 6.09k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 6.09k]
| | ------------------
------------------
1721| 6.09k| added = IGRAPH_CALLOC(no_of_edges, igraph_bool_t);
------------------
| | 33| 6.09k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 12.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 6.09k, False: 0]
| | | | | Branch (31:24): [True: 6.09k, False: 0]
| | | | | Branch (31:66): [True: 4.43k, False: 1.65k]
| | | | ------------------
| | ------------------
------------------
1722| 6.09k| IGRAPH_CHECK_OOM(added, "Cannot create edge iterator.");
------------------
| | 709| 6.09k| do { \
| | 710| 6.09k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 6.09k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.09k]
| | | | ------------------
| | ------------------
| | 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.09k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 6.09k]
| | ------------------
------------------
1723| 6.09k| IGRAPH_FINALLY(igraph_free, added);
------------------
| | 603| 6.09k| do { \
| | 604| 6.09k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.09k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.09k| * incorrect destructor function with the pointer */ \
| | 607| 6.09k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.09k]
| | ------------------
| | 608| 6.09k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.09k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.09k]
| | ------------------
------------------
1724| 69.5k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1724:34): [True: 63.4k, False: 6.09k]
------------------
1725| 63.4k| IGRAPH_CHECK(igraph_incident(graph, &adj, i, IGRAPH_ALL, IGRAPH_LOOPS));
------------------
| | 656| 63.4k| do { \
| | 657| 63.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 63.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 63.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 63.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| 63.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 63.4k]
| | ------------------
------------------
1726| 63.4k| const igraph_int_t length = igraph_vector_int_size(&adj);
1727| 938k| for (igraph_int_t j = 0; j < length; j++) {
------------------
| Branch (1727:38): [True: 875k, False: 63.4k]
------------------
1728| 875k| if (!added[ VECTOR(adj)[j] ]) {
------------------
| | 60| 875k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1728:21): [True: 437k, False: 437k]
------------------
1729| 437k| igraph_vector_int_push_back(vec, VECTOR(adj)[j]); /* reserved */
------------------
| | 60| 437k|#define VECTOR(v) ((v).stor_begin)
------------------
1730| 437k| added[ VECTOR(adj)[j] ] = true;
------------------
| | 60| 437k|#define VECTOR(v) ((v).stor_begin)
------------------
1731| 437k| }
1732| 875k| }
1733| 63.4k| }
1734| 6.09k| igraph_vector_int_destroy(&adj);
1735| 6.09k| IGRAPH_FREE(added);
------------------
| | 36| 6.09k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1736| 6.09k| IGRAPH_FINALLY_CLEAN(2);
1737| 6.09k| }
1738| |
1739| 6.35k| eit->type = IGRAPH_EIT_VECTOR;
1740| 6.35k| eit->pos = 0;
1741| 6.35k| eit->start = 0;
1742| 6.35k| eit->vec = vec;
1743| 6.35k| eit->end = igraph_vector_int_size(eit->vec);
1744| |
1745| 6.35k| IGRAPH_FINALLY_CLEAN(2);
1746| 6.35k| return IGRAPH_SUCCESS;
1747| 6.35k|}
igraph_empty:
64| 6.11k|igraph_error_t igraph_empty(igraph_t *graph, igraph_int_t n, igraph_bool_t directed) {
65| 6.11k| return igraph_empty_attrs(graph, n, directed, 0);
66| 6.11k|}
igraph_edge:
132| 1.75M|) {
133| |
134| 1.75M| if (eid < 0 || eid >= igraph_ecount(graph)) {
------------------
| Branch (134:9): [True: 0, False: 1.75M]
| Branch (134:20): [True: 0, False: 1.75M]
------------------
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.75M| if (igraph_is_directed(graph)) {
------------------
| Branch (138:9): [True: 668k, False: 1.08M]
------------------
139| 668k| *from = IGRAPH_FROM(graph, eid);
------------------
| | 115| 668k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 668k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
140| 668k| *to = IGRAPH_TO(graph, eid);
------------------
| | 128| 668k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 668k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
141| 1.08M| } else {
142| 1.08M| *from = IGRAPH_TO(graph, eid);
------------------
| | 128| 1.08M|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 1.08M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
143| 1.08M| *to = IGRAPH_FROM(graph, eid);
------------------
| | 115| 1.08M|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 1.08M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
144| 1.08M| }
145| |
146| 1.75M| return IGRAPH_SUCCESS;
147| 1.75M|}
igraph_empty_attrs:
102| 15.6k|) {
103| |
104| 15.6k| if (n < 0) {
------------------
| Branch (104:9): [True: 0, False: 15.6k]
------------------
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| 15.6k| memset(graph, 0, sizeof(igraph_t));
109| |
110| 15.6k| graph->n = 0;
111| 15.6k| graph->directed = directed;
112| 15.6k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0);
------------------
| | 119| 15.6k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 15.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 15.6k| do { \
| | | | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | | | 607| 15.6k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 15.6k]
| | | | ------------------
| | | | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 15.6k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 15.6k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 15.6k]
| | ------------------
------------------
113| 15.6k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0);
------------------
| | 119| 15.6k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 15.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 15.6k| do { \
| | | | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | | | 607| 15.6k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 15.6k]
| | | | ------------------
| | | | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 15.6k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 15.6k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 15.6k]
| | ------------------
------------------
114| 15.6k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0);
------------------
| | 119| 15.6k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 15.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 15.6k| do { \
| | | | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | | | 607| 15.6k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 15.6k]
| | | | ------------------
| | | | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 15.6k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 15.6k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 15.6k]
| | ------------------
------------------
115| 15.6k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0);
------------------
| | 119| 15.6k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 15.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 15.6k| do { \
| | | | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | | | 607| 15.6k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 15.6k]
| | | | ------------------
| | | | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 15.6k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 15.6k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 15.6k]
| | ------------------
------------------
116| 15.6k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1);
------------------
| | 119| 15.6k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 15.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 15.6k| do { \
| | | | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | | | 607| 15.6k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 15.6k]
| | | | ------------------
| | | | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 15.6k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 15.6k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 15.6k]
| | ------------------
------------------
117| 15.6k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1);
------------------
| | 119| 15.6k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 15.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 15.6k| do { \
| | | | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | | | 607| 15.6k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 15.6k]
| | | | ------------------
| | | | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 15.6k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 15.6k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 15.6k]
| | ------------------
------------------
118| |
119| | /* init cache */
120| 15.6k| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t);
------------------
| | 33| 15.6k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 31.2k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 15.6k, Folded]
| | | | ------------------
| | ------------------
------------------
121| 15.6k| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph.");
------------------
| | 709| 15.6k| do { \
| | 710| 15.6k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.6k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 15.6k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 15.6k]
| | ------------------
------------------
122| 15.6k| IGRAPH_FINALLY(igraph_free, graph->cache);
------------------
| | 603| 15.6k| do { \
| | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | 607| 15.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.6k]
| | ------------------
| | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.6k]
| | ------------------
------------------
123| 15.6k| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache));
------------------
| | 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]
| | ------------------
------------------
124| 15.6k| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache);
------------------
| | 603| 15.6k| do { \
| | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | 607| 15.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.6k]
| | ------------------
| | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.6k]
| | ------------------
------------------
125| |
126| 15.6k| VECTOR(graph->os)[0] = 0;
------------------
| | 60| 15.6k|#define VECTOR(v) ((v).stor_begin)
------------------
127| 15.6k| VECTOR(graph->is)[0] = 0;
------------------
| | 60| 15.6k|#define VECTOR(v) ((v).stor_begin)
------------------
128| |
129| | /* init attributes */
130| 15.6k| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr));
------------------
| | 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]
| | ------------------
------------------
131| |
132| | /* add the vertices */
133| 15.6k| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0));
------------------
| | 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]
| | ------------------
------------------
134| |
135| 15.6k| IGRAPH_FINALLY_CLEAN(8);
136| 15.6k| return IGRAPH_SUCCESS;
137| 15.6k|}
igraph_destroy:
155| 15.6k|void igraph_destroy(igraph_t *graph) {
156| 15.6k| igraph_i_attribute_destroy(graph);
157| |
158| 15.6k| igraph_i_property_cache_destroy(graph->cache);
159| 15.6k| IGRAPH_FREE(graph->cache);
------------------
| | 36| 15.6k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
160| |
161| 15.6k| igraph_vector_int_destroy(&graph->from);
162| 15.6k| igraph_vector_int_destroy(&graph->to);
163| 15.6k| igraph_vector_int_destroy(&graph->oi);
164| 15.6k| igraph_vector_int_destroy(&graph->ii);
165| 15.6k| igraph_vector_int_destroy(&graph->os);
166| 15.6k| igraph_vector_int_destroy(&graph->is);
167| 15.6k|}
igraph_add_edges:
257| 15.6k|) {
258| 15.6k| igraph_int_t no_of_edges = igraph_vector_int_size(&graph->from);
259| 15.6k| igraph_int_t edges_to_add = igraph_vector_int_size(edges) / 2;
260| 15.6k| igraph_int_t new_no_of_edges;
261| 15.6k| igraph_int_t i = 0;
262| 15.6k| igraph_vector_int_t newoi, newii;
263| 15.6k| igraph_bool_t directed = igraph_is_directed(graph);
264| |
265| 15.6k| if (igraph_vector_int_size(edges) % 2 != 0) {
------------------
| Branch (265:9): [True: 0, False: 15.6k]
------------------
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| 15.6k| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) {
------------------
| Branch (268:9): [True: 0, False: 15.6k]
------------------
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| 15.6k| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges);
------------------
| | 47| 15.6k| do { \
| | 48| 15.6k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 15.6k| igraph_int_t _safe_sum; \
| | 50| 15.6k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 15.6k]
| | ------------------
| | 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| 15.6k| *(res) = _safe_sum; \
| | 54| 15.6k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 15.6k]
| | ------------------
------------------
274| 15.6k| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) {
------------------
| | 118| 15.6k|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2)
| | ------------------
| | | | 72| 15.6k|# define IGRAPH_INTEGER_MAX INT64_MAX
| | ------------------
------------------
| Branch (274:9): [True: 0, False: 15.6k]
------------------
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| 15.6k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add));
------------------
| | 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]
| | ------------------
------------------
279| 15.6k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add));
------------------
| | 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]
| | ------------------
------------------
280| |
281| 1.77M| while (i < edges_to_add * 2) {
------------------
| Branch (281:12): [True: 1.75M, False: 15.6k]
------------------
282| 1.75M| if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) {
------------------
| | 60| 656k|#define VECTOR(v) ((v).stor_begin)
------------------
if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) {
------------------
| | 60| 656k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (282:13): [True: 1.10M, False: 656k]
| Branch (282:25): [True: 232k, False: 423k]
------------------
283| 1.33M| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 1.33M|#define VECTOR(v) ((v).stor_begin)
------------------
284| 1.33M| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 1.33M|#define VECTOR(v) ((v).stor_begin)
------------------
285| 1.33M| } else {
286| 423k| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 423k|#define VECTOR(v) ((v).stor_begin)
------------------
287| 423k| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 423k|#define VECTOR(v) ((v).stor_begin)
------------------
288| 423k| }
289| 1.75M| }
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| 15.6k|#define CHECK_ERR(expr) \
299| 15.6k| do { \
300| 15.6k| igraph_error_t err = (expr); \
301| 15.6k| if (err != IGRAPH_SUCCESS) { \
302| 15.6k| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \
303| 15.6k| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \
304| 15.6k| IGRAPH_FINALLY_EXIT(); \
305| 15.6k| IGRAPH_ERROR("Cannot add edges.", err); \
306| 15.6k| } \
307| 15.6k| } while (0)
308| |
309| | /* oi & ii */
310| 15.6k| IGRAPH_FINALLY_ENTER();
311| 15.6k| {
312| 15.6k| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges));
------------------
| | 299| 15.6k| do { \
| | 300| 15.6k| igraph_error_t err = (expr); \
| | 301| 15.6k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 15.6k]
| | ------------------
| | 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| 15.6k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 15.6k]
| | ------------------
------------------
313| 15.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi);
------------------
| | 603| 15.6k| do { \
| | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | 607| 15.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.6k]
| | ------------------
| | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.6k]
| | ------------------
------------------
314| 15.6k| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges));
------------------
| | 299| 15.6k| do { \
| | 300| 15.6k| igraph_error_t err = (expr); \
| | 301| 15.6k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 15.6k]
| | ------------------
| | 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| 15.6k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 15.6k]
| | ------------------
------------------
315| 15.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii);
------------------
| | 603| 15.6k| do { \
| | 604| 15.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.6k| * incorrect destructor function with the pointer */ \
| | 607| 15.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.6k]
| | ------------------
| | 608| 15.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.6k]
| | ------------------
------------------
316| 15.6k| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n));
------------------
| | 299| 15.6k| do { \
| | 300| 15.6k| igraph_error_t err = (expr); \
| | 301| 15.6k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 15.6k]
| | ------------------
| | 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| 15.6k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 15.6k]
| | ------------------
------------------
317| 15.6k| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n));
------------------
| | 299| 15.6k| do { \
| | 300| 15.6k| igraph_error_t err = (expr); \
| | 301| 15.6k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 15.6k]
| | ------------------
| | 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| 15.6k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 15.6k]
| | ------------------
------------------
318| |
319| | /* Attributes */
320| 15.6k| if (graph->attr) {
------------------
| Branch (320:13): [True: 15.6k, False: 0]
------------------
321| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */
322| 15.6k| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr));
------------------
| | 299| 15.6k| do { \
| | 300| 15.6k| igraph_error_t err = (expr); \
| | 301| 15.6k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 15.6k]
| | ------------------
| | 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| 15.6k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 15.6k]
| | ------------------
------------------
323| 15.6k| }
324| |
325| | /* os & is, its length does not change, error safe */
326| 15.6k| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n);
327| 15.6k| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n);
328| |
329| | /* everything went fine */
330| 15.6k| igraph_vector_int_destroy(&graph->oi);
331| 15.6k| igraph_vector_int_destroy(&graph->ii);
332| 15.6k| IGRAPH_FINALLY_CLEAN(2);
333| |
334| 15.6k| graph->oi = newoi;
335| 15.6k| graph->ii = newii;
336| 15.6k| }
337| 0| IGRAPH_FINALLY_EXIT();
338| |
339| 15.6k|#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| 15.6k| igraph_i_property_cache_invalidate_conditionally(
354| 15.6k| graph,
355| 15.6k| /* keep_always = */ 0,
356| | /* keep_when_false = */
357| 15.6k| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST),
358| | /* keep_when_true = */
359| 15.6k| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) |
360| 15.6k| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) |
361| 15.6k| (1 << IGRAPH_PROP_HAS_LOOP) |
362| 15.6k| (1 << IGRAPH_PROP_HAS_MULTI) |
363| 15.6k| (1 << IGRAPH_PROP_HAS_MUTUAL)
364| 15.6k| );
365| |
366| 15.6k| return IGRAPH_SUCCESS;
367| 15.6k|}
igraph_add_vertices:
391| 31.2k|) {
392| 31.2k| igraph_int_t ec = igraph_ecount(graph);
393| 31.2k| igraph_int_t vc = igraph_vcount(graph);
394| 31.2k| igraph_int_t new_vc;
395| 31.2k| igraph_int_t i;
396| |
397| 31.2k| if (nv < 0) {
------------------
| Branch (397:9): [True: 0, False: 31.2k]
------------------
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| 31.2k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc);
------------------
| | 47| 31.2k| do { \
| | 48| 31.2k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 31.2k| igraph_int_t _safe_sum; \
| | 50| 31.2k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 31.2k]
| | ------------------
| | 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| 31.2k| *(res) = _safe_sum; \
| | 54| 31.2k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 31.2k]
| | ------------------
------------------
402| 31.2k| if (new_vc > IGRAPH_VCOUNT_MAX) {
------------------
| | 100| 31.2k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1)
| | ------------------
| | | | 72| 31.2k|# define IGRAPH_INTEGER_MAX INT64_MAX
| | ------------------
------------------
| Branch (402:9): [True: 0, False: 31.2k]
------------------
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| 31.2k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1));
------------------
| | 656| 31.2k| do { \
| | 657| 31.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 31.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.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| 31.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 31.2k]
| | ------------------
------------------
407| 31.2k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1));
------------------
| | 656| 31.2k| do { \
| | 657| 31.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 31.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.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| 31.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 31.2k]
| | ------------------
------------------
408| |
409| 31.2k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */
410| 31.2k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */
411| 180k| for (i = graph->n + 1; i < new_vc + 1; i++) {
------------------
| Branch (411:28): [True: 148k, False: 31.2k]
------------------
412| 148k| VECTOR(graph->os)[i] = ec;
------------------
| | 60| 148k|#define VECTOR(v) ((v).stor_begin)
------------------
413| 148k| VECTOR(graph->is)[i] = ec;
------------------
| | 60| 148k|#define VECTOR(v) ((v).stor_begin)
------------------
414| 148k| }
415| |
416| 31.2k| 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| 31.2k| if (graph->attr) {
------------------
| Branch (422:9): [True: 31.2k, False: 0]
------------------
423| 31.2k| igraph_error_t err;
424| 31.2k| IGRAPH_FINALLY_ENTER();
425| 31.2k| err = igraph_i_attribute_add_vertices(graph, nv, attr);
426| 31.2k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (426:13): [True: 0, False: 31.2k]
------------------
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| 31.2k| IGRAPH_FINALLY_EXIT();
433| 31.2k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (433:13): [True: 0, False: 31.2k]
------------------
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| 31.2k| }
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| 31.2k| igraph_i_property_cache_invalidate_conditionally(
458| 31.2k| graph,
459| | /* keep_always = */
460| 31.2k| (1 << IGRAPH_PROP_HAS_LOOP) |
461| 31.2k| (1 << IGRAPH_PROP_HAS_MULTI) |
462| 31.2k| (1 << IGRAPH_PROP_HAS_MUTUAL) |
463| 31.2k| (1 << IGRAPH_PROP_IS_DAG) |
464| 31.2k| (1 << IGRAPH_PROP_IS_FOREST),
465| | /* keep_when_false = */
466| 31.2k| igraph_vcount(graph) >= 2 ? (
------------------
| Branch (466:9): [True: 10.6k, False: 20.5k]
------------------
467| 10.6k| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) |
468| 10.6k| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED)
469| 20.5k| ) : 0,
470| | /* keep_when_true = */
471| 31.2k| 0
472| 31.2k| );
473| |
474| 31.2k| return IGRAPH_SUCCESS;
475| 31.2k|}
igraph_vcount:
829| 676k|igraph_int_t igraph_vcount(const igraph_t *graph) {
830| 676k| return graph->n;
831| 676k|}
igraph_ecount:
843| 3.26M|igraph_int_t igraph_ecount(const igraph_t *graph) {
844| 3.26M| return igraph_vector_int_size(&graph->from);
845| 3.26M|}
igraph_is_directed:
1133| 2.21M|igraph_bool_t igraph_is_directed(const igraph_t *graph) {
1134| 2.21M| return graph->directed;
1135| 2.21M|}
igraph_get_eid:
1524| 351k| igraph_bool_t directed, igraph_bool_t error) {
1525| |
1526| 351k| igraph_int_t no_of_nodes = igraph_vcount(graph);
1527| |
1528| 351k| if (from < 0 || to < 0 || from >= no_of_nodes || to >= no_of_nodes) {
------------------
| Branch (1528:9): [True: 0, False: 351k]
| Branch (1528:21): [True: 0, False: 351k]
| Branch (1528:31): [True: 0, False: 351k]
| Branch (1528:54): [True: 0, False: 351k]
------------------
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| 351k| *eid = -1;
1533| 351k| if (igraph_is_directed(graph)) {
------------------
| Branch (1533:9): [True: 133k, False: 217k]
------------------
1534| |
1535| | /* Directed graph */
1536| 133k| FIND_DIRECTED_EDGE(graph, from, to, eid);
------------------
| | 1469| 133k| do { \
| | 1470| 133k| igraph_int_t start = VECTOR(graph->os)[xfrom]; \
| | ------------------
| | | | 60| 133k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1471| 133k| igraph_int_t end = VECTOR(graph->os)[xfrom+1]; \
| | ------------------
| | | | 60| 133k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1472| 133k| igraph_int_t N = end; \
| | 1473| 133k| igraph_int_t start2 = VECTOR(graph->is)[xto]; \
| | ------------------
| | | | 60| 133k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1474| 133k| igraph_int_t end2 = VECTOR(graph->is)[xto+1]; \
| | ------------------
| | | | 60| 133k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1475| 133k| igraph_int_t N2 = end2; \
| | 1476| 133k| igraph_int_t *nullpointer = NULL; \
| | 1477| 133k| if (end-start < end2-start2) { \
| | ------------------
| | | Branch (1477:13): [True: 53.2k, False: 80.4k]
| | ------------------
| | 1478| 53.2k| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \
| | ------------------
| | | | 1449| 53.2k| do { \
| | | | 1450| 290k| while ((start) < (end)) { \
| | | | ------------------
| | | | | Branch (1450:16): [True: 237k, False: 53.2k]
| | | | ------------------
| | | | 1451| 237k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | 1452| 237k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | ------------------
| | | | | | 60| 237k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1453| 237k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | ------------------
| | | | | | 60| 237k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1453:17): [True: 64.4k, False: 173k]
| | | | ------------------
| | | | 1454| 64.4k| (start) = mid+1; \
| | | | 1455| 173k| } else { \
| | | | 1456| 173k| (end) = mid; \
| | | | 1457| 173k| } \
| | | | 1458| 237k| } \
| | | | 1459| 53.2k| if ((start) < (N)) { \
| | | | ------------------
| | | | | Branch (1459:13): [True: 27.4k, False: 25.7k]
| | | | ------------------
| | | | 1460| 27.4k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | ------------------
| | | | | | 60| 27.4k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1461| 27.4k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | ------------------
| | | | | | 60| 27.4k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1461:17): [True: 14.0k, False: 13.4k]
| | | | ------------------
| | | | 1462| 14.0k| *(result) = e; \
| | | | 1463| 14.0k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | ------------------
| | | | | Branch (1463:21): [True: 0, False: 14.0k]
| | | | ------------------
| | | | 1464| 14.0k| } \
| | | | 1465| 27.4k| } \
| | | | 1466| 53.2k| } while (0)
| | | | ------------------
| | | | | Branch (1466:14): [Folded, False: 53.2k]
| | | | ------------------
| | ------------------
| | 1479| 80.4k| } else { \
| | 1480| 80.4k| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \
| | ------------------
| | | | 1449| 80.4k| do { \
| | | | 1450| 755k| while ((start) < (end)) { \
| | | | ------------------
| | | | | Branch (1450:16): [True: 675k, False: 80.4k]
| | | | ------------------
| | | | 1451| 675k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | 1452| 675k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | ------------------
| | | | | | 60| 675k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1453| 675k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | ------------------
| | | | | | 60| 675k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1453:17): [True: 38.6k, False: 636k]
| | | | ------------------
| | | | 1454| 38.6k| (start) = mid+1; \
| | | | 1455| 636k| } else { \
| | | | 1456| 636k| (end) = mid; \
| | | | 1457| 636k| } \
| | | | 1458| 675k| } \
| | | | 1459| 80.4k| if ((start) < (N)) { \
| | | | ------------------
| | | | | Branch (1459:13): [True: 76.5k, False: 3.94k]
| | | | ------------------
| | | | 1460| 76.5k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | ------------------
| | | | | | 60| 76.5k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1461| 76.5k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | ------------------
| | | | | | 60| 76.5k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1461:17): [True: 29.5k, False: 46.9k]
| | | | ------------------
| | | | 1462| 29.5k| *(result) = e; \
| | | | 1463| 29.5k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | ------------------
| | | | | Branch (1463:21): [True: 0, False: 29.5k]
| | | | ------------------
| | | | 1464| 29.5k| } \
| | | | 1465| 76.5k| } \
| | | | 1466| 80.4k| } while (0)
| | | | ------------------
| | | | | Branch (1466:14): [Folded, False: 80.4k]
| | | | ------------------
| | ------------------
| | 1481| 80.4k| } \
| | 1482| 133k| } while (0)
| | ------------------
| | | Branch (1482:14): [Folded, False: 133k]
| | ------------------
------------------
1537| 133k| if (!directed && *eid < 0) {
------------------
| Branch (1537:13): [True: 0, False: 133k]
| 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| 217k| } else {
1542| |
1543| | /* Undirected graph, they only have one mode */
1544| 217k| FIND_UNDIRECTED_EDGE(graph, from, to, eid);
------------------
| | 1485| 217k| do { \
| | 1486| 217k| igraph_int_t xfrom1 = from > to ? from : to; \
| | ------------------
| | | Branch (1486:31): [True: 212k, False: 5.38k]
| | ------------------
| | 1487| 217k| igraph_int_t xto1 = from > to ? to : from; \
| | ------------------
| | | Branch (1487:29): [True: 212k, False: 5.38k]
| | ------------------
| | 1488| 217k| FIND_DIRECTED_EDGE(graph, xfrom1, xto1, eid); \
| | ------------------
| | | | 1469| 217k| do { \
| | | | 1470| 217k| igraph_int_t start = VECTOR(graph->os)[xfrom]; \
| | | | ------------------
| | | | | | 60| 217k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1471| 217k| igraph_int_t end = VECTOR(graph->os)[xfrom+1]; \
| | | | ------------------
| | | | | | 60| 217k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1472| 217k| igraph_int_t N = end; \
| | | | 1473| 217k| igraph_int_t start2 = VECTOR(graph->is)[xto]; \
| | | | ------------------
| | | | | | 60| 217k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1474| 217k| igraph_int_t end2 = VECTOR(graph->is)[xto+1]; \
| | | | ------------------
| | | | | | 60| 217k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1475| 217k| igraph_int_t N2 = end2; \
| | | | 1476| 217k| igraph_int_t *nullpointer = NULL; \
| | | | 1477| 217k| if (end-start < end2-start2) { \
| | | | ------------------
| | | | | Branch (1477:13): [True: 193k, False: 24.3k]
| | | | ------------------
| | | | 1478| 193k| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \
| | | | ------------------
| | | | | | 1449| 193k| do { \
| | | | | | 1450| 2.13M| while ((start) < (end)) { \
| | | | | | ------------------
| | | | | | | Branch (1450:16): [True: 1.94M, False: 193k]
| | | | | | ------------------
| | | | | | 1451| 1.94M| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | | | 1452| 1.94M| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | | | ------------------
| | | | | | | | 60| 1.94M|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1453| 1.94M| if (VECTOR((edgelist))[e] < (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 1.94M|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1453:17): [True: 32.4k, False: 1.91M]
| | | | | | ------------------
| | | | | | 1454| 32.4k| (start) = mid+1; \
| | | | | | 1455| 1.91M| } else { \
| | | | | | 1456| 1.91M| (end) = mid; \
| | | | | | 1457| 1.91M| } \
| | | | | | 1458| 1.94M| } \
| | | | | | 1459| 193k| if ((start) < (N)) { \
| | | | | | ------------------
| | | | | | | Branch (1459:13): [True: 193k, False: 0]
| | | | | | ------------------
| | | | | | 1460| 193k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | | | ------------------
| | | | | | | | 60| 193k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1461| 193k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 193k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1461:17): [True: 193k, False: 0]
| | | | | | ------------------
| | | | | | 1462| 193k| *(result) = e; \
| | | | | | 1463| 193k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | | | ------------------
| | | | | | | Branch (1463:21): [True: 0, False: 193k]
| | | | | | ------------------
| | | | | | 1464| 193k| } \
| | | | | | 1465| 193k| } \
| | | | | | 1466| 193k| } while (0)
| | | | | | ------------------
| | | | | | | Branch (1466:14): [Folded, False: 193k]
| | | | | | ------------------
| | | | ------------------
| | | | 1479| 193k| } else { \
| | | | 1480| 24.3k| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \
| | | | ------------------
| | | | | | 1449| 24.3k| do { \
| | | | | | 1450| 143k| while ((start) < (end)) { \
| | | | | | ------------------
| | | | | | | Branch (1450:16): [True: 118k, False: 24.3k]
| | | | | | ------------------
| | | | | | 1451| 118k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | | | 1452| 118k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | | | ------------------
| | | | | | | | 60| 118k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1453| 118k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 118k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1453:17): [True: 6.93k, False: 111k]
| | | | | | ------------------
| | | | | | 1454| 6.93k| (start) = mid+1; \
| | | | | | 1455| 111k| } else { \
| | | | | | 1456| 111k| (end) = mid; \
| | | | | | 1457| 111k| } \
| | | | | | 1458| 118k| } \
| | | | | | 1459| 24.3k| if ((start) < (N)) { \
| | | | | | ------------------
| | | | | | | Branch (1459:13): [True: 24.3k, False: 0]
| | | | | | ------------------
| | | | | | 1460| 24.3k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | | | ------------------
| | | | | | | | 60| 24.3k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1461| 24.3k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 24.3k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1461:17): [True: 24.3k, False: 0]
| | | | | | ------------------
| | | | | | 1462| 24.3k| *(result) = e; \
| | | | | | 1463| 24.3k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | | | ------------------
| | | | | | | Branch (1463:21): [True: 0, False: 24.3k]
| | | | | | ------------------
| | | | | | 1464| 24.3k| } \
| | | | | | 1465| 24.3k| } \
| | | | | | 1466| 24.3k| } while (0)
| | | | | | ------------------
| | | | | | | Branch (1466:14): [Folded, False: 24.3k]
| | | | | | ------------------
| | | | ------------------
| | | | 1481| 24.3k| } \
| | | | 1482| 217k| } while (0)
| | | | ------------------
| | | | | Branch (1482:14): [Folded, False: 217k]
| | | | ------------------
| | ------------------
| | 1489| 217k| } while (0)
| | ------------------
| | | Branch (1489:14): [Folded, False: 217k]
| | ------------------
------------------
1545| |
1546| 217k| }
1547| |
1548| 351k| if (*eid < 0) {
------------------
| Branch (1548:9): [True: 90.0k, False: 261k]
------------------
1549| 90.0k| if (error) {
------------------
| Branch (1549:13): [True: 0, False: 90.0k]
------------------
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| 90.0k| }
1553| |
1554| 351k| return IGRAPH_SUCCESS;
1555| 351k|}
igraph_incident:
1778| 65.8k|) {
1779| 65.8k| igraph_int_t length = 0, idx = 0;
1780| 65.8k| igraph_int_t i, j;
1781| 65.8k| igraph_int_t node = pnode;
1782| 65.8k| igraph_bool_t directed = igraph_is_directed(graph);
1783| |
1784| 65.8k| if (node < 0 || node > igraph_vcount(graph) - 1) {
------------------
| Branch (1784:9): [True: 0, False: 65.8k]
| Branch (1784:21): [True: 0, False: 65.8k]
------------------
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| 65.8k| if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
------------------
| Branch (1787:9): [True: 63.4k, False: 2.47k]
| Branch (1787:31): [True: 63.4k, False: 0]
------------------
1788| 63.4k| mode != IGRAPH_ALL) {
------------------
| Branch (1788:9): [True: 0, False: 63.4k]
------------------
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| 65.8k| if (!directed) {
------------------
| Branch (1792:9): [True: 63.4k, False: 2.47k]
------------------
1793| 63.4k| mode = IGRAPH_ALL;
1794| 63.4k| }
1795| |
1796| 65.8k| if (mode != IGRAPH_ALL && loops == IGRAPH_LOOPS_TWICE) {
------------------
| Branch (1796:9): [True: 2.47k, False: 63.4k]
| Branch (1796:31): [True: 2.47k, 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.47k| loops = IGRAPH_LOOPS_ONCE;
1802| 2.47k| }
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| 65.8k| if (mode & IGRAPH_OUT) {
------------------
| Branch (1807:9): [True: 65.8k, False: 0]
------------------
1808| 65.8k| length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]);
------------------
| | 60| 65.8k|#define VECTOR(v) ((v).stor_begin)
------------------
length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]);
------------------
| | 60| 65.8k|#define VECTOR(v) ((v).stor_begin)
------------------
1809| 65.8k| }
1810| 65.8k| if (mode & IGRAPH_IN) {
------------------
| Branch (1810:9): [True: 63.4k, False: 2.47k]
------------------
1811| 63.4k| length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]);
------------------
| | 60| 63.4k|#define VECTOR(v) ((v).stor_begin)
------------------
length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]);
------------------
| | 60| 63.4k|#define VECTOR(v) ((v).stor_begin)
------------------
1812| 63.4k| }
1813| |
1814| 65.8k| IGRAPH_CHECK(igraph_vector_int_resize(eids, length));
------------------
| | 656| 65.8k| do { \
| | 657| 65.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 65.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 65.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 65.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| 65.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 65.8k]
| | ------------------
------------------
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| 65.8k| if (!directed || mode != IGRAPH_ALL) {
------------------
| Branch (1823:9): [True: 63.4k, False: 2.47k]
| Branch (1823:22): [True: 2.47k, False: 0]
------------------
1824| | /* We did not ask for both directions; this is the easy case */
1825| |
1826| 65.8k| if (mode & IGRAPH_OUT) {
------------------
| Branch (1826:13): [True: 65.8k, False: 0]
------------------
1827| 65.8k| j = VECTOR(graph->os)[node + 1];
------------------
| | 60| 65.8k|#define VECTOR(v) ((v).stor_begin)
------------------
1828| 770k| for (i = VECTOR(graph->os)[node]; i < j; i++) {
------------------
| | 60| 65.8k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1828:47): [True: 704k, False: 65.8k]
------------------
1829| 704k| igraph_int_t edge = VECTOR(graph->oi)[i];
------------------
| | 60| 704k|#define VECTOR(v) ((v).stor_begin)
------------------
1830| 704k| igraph_int_t other = VECTOR(graph->to)[edge];
------------------
| | 60| 704k|#define VECTOR(v) ((v).stor_begin)
------------------
1831| 704k| if (loops == IGRAPH_NO_LOOPS && other == pnode) {
------------------
| Branch (1831:21): [True: 0, False: 704k]
| Branch (1831:49): [True: 0, False: 0]
------------------
1832| 0| length--;
1833| 704k| } else {
1834| 704k| VECTOR(*eids)[idx++] = edge;
------------------
| | 60| 704k|#define VECTOR(v) ((v).stor_begin)
------------------
1835| 704k| }
1836| 704k| }
1837| 65.8k| }
1838| |
1839| 65.8k| if (mode & IGRAPH_IN) {
------------------
| Branch (1839:13): [True: 63.4k, False: 2.47k]
------------------
1840| 63.4k| j = VECTOR(graph->is)[node + 1];
------------------
| | 60| 63.4k|#define VECTOR(v) ((v).stor_begin)
------------------
1841| 500k| for (i = VECTOR(graph->is)[node]; i < j; i++) {
------------------
| | 60| 63.4k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1841:47): [True: 437k, False: 63.4k]
------------------
1842| 437k| igraph_int_t edge = VECTOR(graph->ii)[i];
------------------
| | 60| 437k|#define VECTOR(v) ((v).stor_begin)
------------------
1843| 437k| igraph_int_t other = VECTOR(graph->from)[edge];
------------------
| | 60| 437k|#define VECTOR(v) ((v).stor_begin)
------------------
1844| 437k| if ((loops == IGRAPH_NO_LOOPS || (loops == IGRAPH_LOOPS_ONCE && !directed)) && other == pnode) {
------------------
| Branch (1844:22): [True: 0, False: 437k]
| Branch (1844:51): [True: 0, False: 437k]
| Branch (1844:81): [True: 0, False: 0]
| Branch (1844:96): [True: 0, False: 0]
------------------
1845| 0| length--;
1846| 437k| } else {
1847| 437k| VECTOR(*eids)[idx++] = edge;
------------------
| | 60| 437k|#define VECTOR(v) ((v).stor_begin)
------------------
1848| 437k| }
1849| 437k| }
1850| 63.4k| }
1851| 65.8k| } 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| 65.8k| IGRAPH_CHECK(igraph_vector_int_resize(eids, length));
------------------
| | 656| 65.8k| do { \
| | 657| 65.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 65.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 65.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 65.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| 65.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 65.8k]
| | ------------------
------------------
1911| 65.8k| return IGRAPH_SUCCESS;
1912| 65.8k|}
type_indexededgelist.c:igraph_i_create_start_vectors:
1076| 31.2k| igraph_vector_int_t *iindex, igraph_int_t nodes) {
1077| |
1078| 31.2k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
1079| |
1080| 31.2k| igraph_int_t no_of_nodes;
1081| 31.2k| igraph_int_t no_of_edges;
1082| 31.2k| igraph_int_t i, j, idx;
1083| |
1084| 31.2k| no_of_nodes = nodes;
1085| 31.2k| no_of_edges = igraph_vector_int_size(el);
1086| |
1087| | /* result */
1088| |
1089| 31.2k| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1));
------------------
| | 656| 31.2k| do { \
| | 657| 31.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 31.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.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| 31.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 31.2k]
| | ------------------
------------------
1090| |
1091| | /* create the index */
1092| |
1093| 31.2k| if (no_of_edges == 0) {
------------------
| Branch (1093:9): [True: 8.26k, False: 22.9k]
------------------
1094| | /* empty graph */
1095| 8.26k| igraph_vector_int_null(res);
1096| 22.9k| } else {
1097| 22.9k| idx = -1;
1098| 56.3k| for (i = 0; i <= EDGE(0); i++) {
------------------
| | 1078| 56.3k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 56.3k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 56.3k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (1098:21): [True: 33.3k, False: 22.9k]
------------------
1099| 33.3k| idx++; VECTOR(*res)[idx] = 0;
------------------
| | 60| 33.3k|#define VECTOR(v) ((v).stor_begin)
------------------
1100| 33.3k| }
1101| 3.51M| for (i = 1; i < no_of_edges; i++) {
------------------
| Branch (1101:21): [True: 3.49M, False: 22.9k]
------------------
1102| 3.49M| igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 3.49M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 3.49M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 3.49M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 3.49M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 3.49M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 3.49M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1103| 3.73M| for (j = 0; j < n; j++) {
------------------
| Branch (1103:25): [True: 245k, False: 3.49M]
------------------
1104| 245k| idx++; VECTOR(*res)[idx] = i;
------------------
| | 60| 245k|#define VECTOR(v) ((v).stor_begin)
------------------
1105| 245k| }
1106| 3.49M| }
1107| 22.9k| j = EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 22.9k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 22.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 22.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1108| 63.6k| for (i = 0; i < no_of_nodes - j; i++) {
------------------
| Branch (1108:21): [True: 40.7k, False: 22.9k]
------------------
1109| 40.7k| idx++; VECTOR(*res)[idx] = no_of_edges;
------------------
| | 60| 40.7k|#define VECTOR(v) ((v).stor_begin)
------------------
1110| 40.7k| }
1111| 22.9k| }
1112| |
1113| | /* clean */
1114| |
1115| 31.2k|# undef EDGE
1116| 31.2k| return IGRAPH_SUCCESS;
1117| 31.2k|}
igraph_qsort:
264| 39|{
265| | local_qsort(a, n, es, cmp, NULL);
266| 39|}
qsort.c:local_qsort:
121| 39|{
122| 39| char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
123| 39| size_t d1, d2;
124| 39| int cmp_result;
125| 39| int swap_cnt;
126| |
127| | /* if there are less than 2 elements, then sorting is not needed */
128| 39| if (IGRAPH_UNLIKELY(n < 2))
------------------
| | 612| 39| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | ------------------
| | | Branch (612:32): [True: 0, False: 39]
| | ------------------
------------------
129| 0| return;
130| 39|loop:
131| 39| swap_cnt = 0;
132| 39| if (n < 7) {
------------------
| Branch (132:6): [True: 5, False: 34]
------------------
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| 34| pm = (char *)a + (n / 2) * es;
141| 34| if (n > 7) {
------------------
| Branch (141:6): [True: 33, False: 1]
------------------
142| 33| pl = a;
143| 33| pn = (char *)a + (n - 1) * es;
144| 33| if (n > 40) {
------------------
| Branch (144:7): [True: 16, False: 17]
------------------
145| 16| size_t d = (n / 8) * es;
146| |
147| 16| pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk);
148| 16| pm = med3(pm - d, pm, pm + d, cmp, thunk);
149| 16| pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk);
150| 16| }
151| 33| pm = med3(pl, pm, pn, cmp, thunk);
152| 33| }
153| 34| swapfunc(a, pm, es);
154| 34| pa = pb = (char *)a + es;
155| |
156| 34| pc = pd = (char *)a + (n - 1) * es;
157| 34| for (;;) {
158| 2.06k| while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) {
------------------
| | 95| 2.02k|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (158:10): [True: 2.02k, False: 34]
| Branch (158:22): [True: 2.02k, False: 0]
------------------
159| 2.02k| if (cmp_result == 0) {
------------------
| Branch (159:8): [True: 2.02k, False: 0]
------------------
160| 2.02k| swap_cnt = 1;
161| 2.02k| swapfunc(pa, pb, es);
162| 2.02k| pa += es;
163| 2.02k| }
164| 2.02k| pb += es;
165| 2.02k| }
166| 34| 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: 34]
| 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| 34| if (pb > pc)
------------------
| Branch (174:7): [True: 34, False: 0]
------------------
175| 34| break;
176| 0| swapfunc(pb, pc, es);
177| 0| swap_cnt = 1;
178| 0| pb += es;
179| 0| pc -= es;
180| 0| }
181| 34| if (swap_cnt == 0) { /* Switch to insertion sort */
------------------
| Branch (181:6): [True: 0, False: 34]
------------------
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| 34| pn = (char *)a + n * es;
191| 34| d1 = MIN(pa - (char *)a, pb - pa);
------------------
| | 69| 34|#define MIN(a, b) ((a) < (b) ? a : b)
| | ------------------
| | | Branch (69:20): [True: 0, False: 34]
| | ------------------
------------------
192| 34| vecswap(a, pb - d1, d1);
------------------
| | 88| 34| if ((n) > 0) swapfunc(a, b, n)
| | ------------------
| | | Branch (88:6): [True: 0, False: 34]
| | ------------------
------------------
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| 34| d1 = MIN(pd - pc, pn - pd - (ptrdiff_t)es);
------------------
| | 69| 34|#define MIN(a, b) ((a) < (b) ? a : b)
| | ------------------
| | | Branch (69:20): [True: 0, False: 34]
| | ------------------
------------------
199| 34| vecswap(pb, pn - d1, d1);
------------------
| | 88| 34| if ((n) > 0) swapfunc(a, b, n)
| | ------------------
| | | Branch (88:6): [True: 0, False: 34]
| | ------------------
------------------
200| |
201| 34| d1 = pb - pa;
202| 34| d2 = pd - pc;
203| 34| if (d1 <= d2) {
------------------
| Branch (203:6): [True: 34, False: 0]
------------------
204| | /* Recurse on left partition, then iterate on right partition */
205| 34| if (d1 > es) {
------------------
| Branch (205:7): [True: 0, False: 34]
------------------
206| 0| local_qsort(a, d1 / es, es, cmp, thunk);
207| 0| }
208| 34| if (d2 > es) {
------------------
| Branch (208:7): [True: 0, False: 34]
------------------
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| 34| } 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| 34|}
qsort.c:swapfunc:
77| 2.06k|{
78| 2.06k| char t;
79| |
80| 16.5k| do {
81| 16.5k| t = *a;
82| 16.5k| *a++ = *b;
83| 16.5k| *b++ = t;
84| 16.5k| } while (--es > 0);
------------------
| Branch (84:11): [True: 14.4k, False: 2.06k]
------------------
85| 2.06k|}
qsort.c:med3:
104| 81|{
105| 81| return CMP(thunk, a, b) < 0 ?
------------------
| | 95| 81|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (105:9): [True: 0, False: 81]
------------------
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| 81| :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));
------------------
| | 95| 81|#define CMP(t, x, y) (cmp((x), (y)))
------------------
:(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));
------------------
| | 95| 81|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (107:10): [True: 0, False: 81]
| Branch (107:38): [True: 0, False: 81]
------------------
108| 81|}
igraph_write_graph_dot:
160| 3.17k|igraph_error_t igraph_write_graph_dot(const igraph_t *graph, FILE* outstream) {
161| 3.17k| const igraph_int_t no_of_nodes = igraph_vcount(graph);
162| 3.17k| const igraph_int_t no_of_edges = igraph_ecount(graph);
163| 3.17k| const igraph_bool_t directed = igraph_is_directed(graph);
164| 3.17k| const char *edgeop = directed ? "->" : "--";
------------------
| Branch (164:26): [True: 133, False: 3.04k]
------------------
165| 3.17k| igraph_strvector_t gnames, vnames, enames;
166| 3.17k| igraph_vector_int_t gtypes, vtypes, etypes;
167| 3.17k| igraph_vector_t numv;
168| 3.17k| igraph_strvector_t strv;
169| 3.17k| igraph_vector_bool_t boolv;
170| 3.17k| igraph_vector_char_t buf, buf2;
171| |
172| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
173| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
174| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
175| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
176| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
177| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
178| 3.17k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
179| 3.17k| &gnames, >ypes,
180| 3.17k| &vnames, &vtypes,
181| 3.17k| &enames, &etypes));
182| |
183| 3.17k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 0);
------------------
| | 104| 3.17k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 105| 3.17k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.17k]
| | ------------------
------------------
184| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
185| 3.17k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 0);
------------------
| | 109| 3.17k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 110| 3.17k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.17k]
| | ------------------
------------------
186| |
187| 3.17k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&buf, 0);
------------------
| | 114| 3.17k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 115| 3.17k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 3.17k]
| | ------------------
------------------
188| 3.17k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&buf2, 0);
------------------
| | 114| 3.17k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 115| 3.17k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 3.17k]
| | ------------------
------------------
189| |
190| 3.17k| CHECK(fprintf(outstream, "/* Created by igraph %s */\n", IGRAPH_VERSION));
------------------
| | 37| 3.17k|#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.17k]
| | | Branch (37:116): [Folded, False: 3.17k]
| | ------------------
------------------
191| |
192| 3.17k| if (directed) {
------------------
| Branch (192:9): [True: 133, False: 3.04k]
------------------
193| 133| CHECK(fprintf(outstream, "digraph {\n"));
------------------
| | 37| 133|#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: 133]
| | | Branch (37:116): [Folded, False: 133]
| | ------------------
------------------
194| 3.04k| } else {
195| 3.04k| CHECK(fprintf(outstream, "graph {\n"));
------------------
| | 37| 3.04k|#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.04k]
| | | Branch (37:116): [Folded, False: 3.04k]
| | ------------------
------------------
196| 3.04k| }
197| |
198| | /* Write the graph attributes */
199| 3.17k| if (igraph_vector_int_size(>ypes) > 0) {
------------------
| Branch (199:9): [True: 515, False: 2.66k]
------------------
200| 515| CHECK(fprintf(outstream, " graph [\n"));
------------------
| | 37| 515|#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: 515]
| | | Branch (37:116): [Folded, False: 515]
| | ------------------
------------------
201| 1.32k| for (igraph_int_t i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (201:34): [True: 811, False: 515]
------------------
202| 811| const char *name;
203| 811| name = igraph_strvector_get(&gnames, i);
204| 811| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 656| 811| do { \
| | 657| 811| igraph_error_t igraph_i_ret = (expr); \
| | 658| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 811]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 811| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 811]
| | ------------------
------------------
205| 811| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 811|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (205:17): [True: 111, False: 700]
------------------
206| 111| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 111| do { \
| | 657| 111| igraph_error_t igraph_i_ret = (expr); \
| | 658| 111| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 111| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 111]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 111| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 111]
| | ------------------
------------------
207| 111| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 111|#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: 111]
| | | Branch (37:116): [Folded, False: 111]
| | ------------------
------------------
208| 111| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 111| do { \
| | 657| 111| igraph_error_t igraph_i_ret = (expr); \
| | 658| 111| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 111| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 111]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 111| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 111]
| | ------------------
------------------
209| 111| CHECK(fputc('\n', outstream));
------------------
| | 37| 111|#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: 111]
| | | Branch (37:116): [Folded, False: 111]
| | ------------------
------------------
210| 700| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 700|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (210:24): [True: 563, False: 137]
------------------
211| 563| const char *s;
212| 563| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 563| do { \
| | 657| 563| igraph_error_t igraph_i_ret = (expr); \
| | 658| 563| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 563| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 563]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 563| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 563]
| | ------------------
------------------
213| 563| s = igraph_strvector_get(&strv, 0);
214| 563| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 563| do { \
| | 657| 563| igraph_error_t igraph_i_ret = (expr); \
| | 658| 563| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 563| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 563]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 563| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 563]
| | ------------------
------------------
215| 563| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 563|#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: 563]
| | | Branch (37:116): [Folded, False: 563]
| | ------------------
------------------
216| 563| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 137|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (216:24): [True: 137, False: 0]
------------------
217| 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]
| | ------------------
------------------
218| 137| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 274|#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: 1, False: 136]
| | | Branch (37:42): [True: 0, False: 137]
| | | Branch (37:116): [Folded, False: 137]
| | ------------------
------------------
219| 137| IGRAPH_WARNING("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]
| | ------------------
------------------
220| 137| } 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| 811| }
224| 515| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 515|#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: 515]
| | | Branch (37:116): [Folded, False: 515]
| | ------------------
------------------
225| 515| }
226| |
227| | /* Write the vertices */
228| 3.17k| if (igraph_vector_int_size(&vtypes) > 0) {
------------------
| Branch (228:9): [True: 3.16k, False: 13]
------------------
229| 35.7k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (229:34): [True: 32.5k, False: 3.16k]
------------------
230| 32.5k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " [\n", i));
------------------
| | 37| 32.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: 32.5k]
| | | Branch (37:116): [Folded, False: 32.5k]
| | ------------------
------------------
231| 84.2k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vtypes); j++) {
------------------
| Branch (231:38): [True: 51.6k, False: 32.5k]
------------------
232| 51.6k| const char *name;
233| 51.6k| name = igraph_strvector_get(&vnames, j);
234| 51.6k| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 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]
| | ------------------
------------------
235| 51.6k| if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 51.6k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (235:21): [True: 5.42k, False: 46.2k]
------------------
236| 5.42k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name, igraph_vss_1(i), &numv));
------------------
| | 656| 5.42k| do { \
| | 657| 5.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.42k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.42k]
| | ------------------
------------------
237| 5.42k| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 5.42k|#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.42k]
| | | Branch (37:116): [Folded, False: 5.42k]
| | ------------------
------------------
238| 5.42k| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 5.42k| do { \
| | 657| 5.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.42k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.42k]
| | ------------------
------------------
239| 5.42k| CHECK(fputc('\n', outstream));
------------------
| | 37| 5.42k|#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.42k]
| | | Branch (37:116): [Folded, False: 5.42k]
| | ------------------
------------------
240| 46.2k| } else if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 46.2k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (240:28): [True: 42.1k, False: 4.13k]
------------------
241| 42.1k| const char *s;
242| 42.1k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name, igraph_vss_1(i), &strv));
------------------
| | 656| 42.1k| do { \
| | 657| 42.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.1k]
| | ------------------
------------------
243| 42.1k| s = igraph_strvector_get(&strv, 0);
244| 42.1k| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 42.1k| do { \
| | 657| 42.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.1k]
| | ------------------
------------------
245| 42.1k| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 42.1k|#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.1k]
| | | Branch (37:116): [Folded, False: 42.1k]
| | ------------------
------------------
246| 42.1k| } else if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 4.13k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (246:28): [True: 4.13k, False: 0]
------------------
247| 4.13k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name, igraph_vss_1(i), &boolv));
------------------
| | 656| 4.13k| do { \
| | 657| 4.13k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.13k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.13k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.13k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.13k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.13k]
| | ------------------
------------------
248| 4.13k| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 8.27k|#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.12k]
| | | Branch (37:42): [True: 0, False: 4.13k]
| | | Branch (37:116): [Folded, False: 4.13k]
| | ------------------
------------------
249| 4.13k| IGRAPH_WARNING("A boolean vertex attribute was converted to numeric.");
------------------
| | 797| 4.13k| do { \
| | 798| 4.13k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 4.13k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 4.13k]
| | ------------------
------------------
250| 4.13k| } 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| 51.6k| }
254| 32.5k| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 32.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: 32.5k]
| | | Branch (37:116): [Folded, False: 32.5k]
| | ------------------
------------------
255| 32.5k| }
256| 3.16k| } else {
257| 376| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (257:34): [True: 363, False: 13]
------------------
258| 363| CHECK(fprintf(outstream, " %" IGRAPH_PRId ";\n", i));
------------------
| | 37| 363|#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: 363]
| | | Branch (37:116): [Folded, False: 363]
| | ------------------
------------------
259| 363| }
260| 13| }
261| 3.17k| CHECK(fprintf(outstream, "\n"));
------------------
| | 37| 3.17k|#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.17k]
| | | Branch (37:116): [Folded, False: 3.17k]
| | ------------------
------------------
262| |
263| | /* Write the edges */
264| 3.17k| if (igraph_vector_int_size(&etypes) > 0) {
------------------
| Branch (264:9): [True: 1.57k, False: 1.60k]
------------------
265| 189k| for (igraph_int_t i = 0; i < no_of_edges; i++) {
------------------
| Branch (265:34): [True: 187k, False: 1.57k]
------------------
266| 187k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 187k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 187k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
267| 187k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 187k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 187k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
268| 187k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " %s %" IGRAPH_PRId " [\n", from, edgeop, to));
------------------
| | 37| 187k|#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: 187k]
| | | Branch (37:116): [Folded, False: 187k]
| | ------------------
------------------
269| 636k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&etypes); j++) {
------------------
| Branch (269:38): [True: 448k, False: 187k]
------------------
270| 448k| const char *name;
271| 448k| name = igraph_strvector_get(&enames, j);
272| 448k| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 656| 448k| do { \
| | 657| 448k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 448k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 448k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 448k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 448k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 448k]
| | ------------------
------------------
273| 448k| if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 448k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (273:21): [True: 94.6k, False: 353k]
------------------
274| 94.6k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph,
------------------
| | 656| 94.6k| do { \
| | 657| 94.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 94.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 94.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.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| 94.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 94.6k]
| | ------------------
------------------
275| 94.6k| name, igraph_ess_1(i), &numv));
276| 94.6k| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 94.6k|#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: 94.6k]
| | | Branch (37:116): [Folded, False: 94.6k]
| | ------------------
------------------
277| 94.6k| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 94.6k| do { \
| | 657| 94.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 94.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 94.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.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| 94.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 94.6k]
| | ------------------
------------------
278| 94.6k| CHECK(fputc('\n', outstream));
------------------
| | 37| 94.6k|#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: 94.6k]
| | | Branch (37:116): [Folded, False: 94.6k]
| | ------------------
------------------
279| 353k| } else if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 353k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (279:28): [True: 347k, False: 5.88k]
------------------
280| 347k| const char *s;
281| 347k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph,
------------------
| | 656| 347k| do { \
| | 657| 347k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 347k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 347k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 347k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 347k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 347k]
| | ------------------
------------------
282| 347k| name, igraph_ess_1(i), &strv));
283| 347k| s = igraph_strvector_get(&strv, 0);
284| 347k| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 347k| do { \
| | 657| 347k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 347k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 347k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 347k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 347k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 347k]
| | ------------------
------------------
285| 347k| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 347k|#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: 347k]
| | | Branch (37:116): [Folded, False: 347k]
| | ------------------
------------------
286| 347k| } else if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 5.88k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (286:28): [True: 5.88k, False: 0]
------------------
287| 5.88k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph,
------------------
| | 656| 5.88k| do { \
| | 657| 5.88k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.88k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.88k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.88k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.88k]
| | ------------------
------------------
288| 5.88k| name, igraph_ess_1(i), &boolv));
289| 5.88k| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 11.7k|#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: 5.88k]
| | | Branch (37:42): [True: 0, False: 5.88k]
| | | Branch (37:116): [Folded, False: 5.88k]
| | ------------------
------------------
290| 5.88k| IGRAPH_WARNING("A boolean edge attribute was converted to numeric.");
------------------
| | 797| 5.88k| do { \
| | 798| 5.88k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 5.88k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 5.88k]
| | ------------------
------------------
291| 5.88k| } 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| 448k| }
295| 187k| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 187k|#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: 187k]
| | | Branch (37:116): [Folded, False: 187k]
| | ------------------
------------------
296| 187k| }
297| 1.60k| } else {
298| 166k| for (igraph_int_t i = 0; i < no_of_edges; i++) {
------------------
| Branch (298:34): [True: 164k, False: 1.60k]
------------------
299| 164k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 164k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 164k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
300| 164k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 164k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 164k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
301| 164k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " %s %" IGRAPH_PRId ";\n", from, edgeop, to));
------------------
| | 37| 164k|#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: 164k]
| | | Branch (37:116): [Folded, False: 164k]
| | ------------------
------------------
302| 164k| }
303| 1.60k| }
304| 3.17k| CHECK(fprintf(outstream, "}\n"));
------------------
| | 37| 3.17k|#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.17k]
| | | Branch (37:116): [Folded, False: 3.17k]
| | ------------------
------------------
305| |
306| 3.17k| igraph_vector_char_destroy(&buf2);
307| 3.17k| igraph_vector_char_destroy(&buf);
308| 3.17k| igraph_vector_bool_destroy(&boolv);
309| 3.17k| igraph_strvector_destroy(&strv);
310| 3.17k| igraph_vector_destroy(&numv);
311| 3.17k| igraph_vector_int_destroy(&etypes);
312| 3.17k| igraph_vector_int_destroy(&vtypes);
313| 3.17k| igraph_vector_int_destroy(>ypes);
314| 3.17k| igraph_strvector_destroy(&enames);
315| 3.17k| igraph_strvector_destroy(&vnames);
316| 3.17k| igraph_strvector_destroy(&gnames);
317| 3.17k| IGRAPH_FINALLY_CLEAN(11);
318| |
319| 3.17k| return IGRAPH_SUCCESS;
320| 3.17k|}
dot.c:dot_escape:
39| 986k|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| 986k| igraph_int_t i, j, len = strlen(orig), newlen = 0;
42| 986k| 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| 986k| if (!strcasecmp(orig, "graph") || !strcasecmp(orig, "digraph") ||
------------------
| Branch (45:9): [True: 198, False: 986k]
| Branch (45:39): [True: 98, False: 985k]
------------------
46| 985k| !strcasecmp(orig, "node") || !strcasecmp(orig, "edge") ||
------------------
| Branch (46:9): [True: 195, False: 985k]
| Branch (46:38): [True: 198, False: 985k]
------------------
47| 985k| !strcasecmp(orig, "strict") || !strcasecmp(orig, "subgraph") || len == 0) {
------------------
| Branch (47:9): [True: 200, False: 985k]
| Branch (47:40): [True: 2.81k, False: 982k]
| Branch (47:73): [True: 112k, False: 870k]
------------------
48| 116k| need_quote = true;
49| 116k| is_number = false;
50| 116k| }
51| |
52| | /* next, check whether we need to escape the string for any other reason.
53| | * Also update is_number and newlen */
54| 227M| for (i = 0; i < len; i++) {
------------------
| Branch (54:17): [True: 226M, False: 986k]
------------------
55| 226M| if (isdigit(orig[i])) {
------------------
| Branch (55:13): [True: 6.71M, False: 219M]
------------------
56| 6.71M| newlen++;
57| 219M| } else if (orig[i] == '-' && i == 0) {
------------------
| Branch (57:20): [True: 2.56M, False: 217M]
| Branch (57:38): [True: 3.25k, False: 2.56M]
------------------
58| 3.25k| newlen++;
59| 219M| } else if (orig[i] == '.') {
------------------
| Branch (59:20): [True: 879k, False: 219M]
------------------
60| 879k| if (is_number) {
------------------
| Branch (60:17): [True: 6.65k, False: 872k]
------------------
61| 6.65k| newlen++;
62| 872k| } else {
63| 872k| need_quote = true;
64| 872k| newlen++;
65| 872k| }
66| 219M| } else if (orig[i] == '_') {
------------------
| Branch (66:20): [True: 3.91M, False: 215M]
------------------
67| 3.91M| is_number = false; newlen++;
68| 215M| } else if (orig[i] == '\\' || orig[i] == '"' || orig[i] == '\n') {
------------------
| Branch (68:20): [True: 11.5k, False: 215M]
| Branch (68:39): [True: 14.1M, False: 201M]
| Branch (68:57): [True: 12.1M, False: 188M]
------------------
69| 26.3M| need_quote = true; is_number = false; newlen += 2; /* will be escaped */
70| 188M| } else if (isalpha(orig[i])) {
------------------
| Branch (70:20): [True: 47.8M, False: 141M]
------------------
71| 47.8M| is_number = false; newlen++;
72| 141M| } else {
73| 141M| is_number = false; need_quote = true; newlen++;
74| 141M| }
75| 226M| }
76| 986k| if (is_number && len > 0 && orig[len - 1] == '.') {
------------------
| Branch (76:9): [True: 4.96k, False: 981k]
| Branch (76:22): [True: 4.96k, False: 0]
| Branch (76:33): [True: 272, False: 4.69k]
------------------
77| 272| is_number = false;
78| 272| }
79| 986k| if (!is_number && isdigit(orig[0])) {
------------------
| Branch (79:9): [True: 981k, False: 4.69k]
| Branch (79:23): [True: 3.23k, False: 978k]
------------------
80| 3.23k| need_quote = true;
81| 3.23k| }
82| |
83| 986k| if (is_number || !need_quote) {
------------------
| Branch (83:9): [True: 4.69k, False: 981k]
| Branch (83:22): [True: 823k, False: 158k]
------------------
84| 827k| IGRAPH_CHECK(igraph_vector_char_resize(result, newlen + 1));
------------------
| | 656| 827k| do { \
| | 657| 827k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 827k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 827k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 827k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 827k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 827k]
| | ------------------
------------------
85| 827k| memcpy(VECTOR(*result), orig, newlen);
------------------
| | 60| 827k|#define VECTOR(v) ((v).stor_begin)
------------------
86| 827k| } else {
87| 158k| newlen += 2;
88| 158k| IGRAPH_CHECK(igraph_vector_char_resize(result, newlen + 1));
------------------
| | 656| 158k| do { \
| | 657| 158k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 158k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 158k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 158k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 158k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 158k]
| | ------------------
------------------
89| 158k| VECTOR(*result)[0] = '"';
------------------
| | 60| 158k|#define VECTOR(v) ((v).stor_begin)
------------------
90| 158k| VECTOR(*result)[newlen - 1] = '"';
------------------
| | 60| 158k|#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| 211M| for (i = 0, j = 1; i < len; i++) {
------------------
| Branch (97:28): [True: 211M, False: 158k]
------------------
98| 211M| if (orig[i] == '\n') {
------------------
| Branch (98:17): [True: 12.1M, False: 199M]
------------------
99| 12.1M| VECTOR(*result)[j++] = '\\';
------------------
| | 60| 12.1M|#define VECTOR(v) ((v).stor_begin)
------------------
100| 12.1M| VECTOR(*result)[j++] = 'n';
------------------
| | 60| 12.1M|#define VECTOR(v) ((v).stor_begin)
------------------
101| 12.1M| continue;
102| 12.1M| }
103| 199M| if (orig[i] == '\\' || orig[i] == '"') {
------------------
| Branch (103:17): [True: 11.5k, False: 199M]
| Branch (103:36): [True: 14.1M, False: 185M]
------------------
104| 14.1M| VECTOR(*result)[j++] = '\\';
------------------
| | 60| 14.1M|#define VECTOR(v) ((v).stor_begin)
------------------
105| 14.1M| }
106| 199M| VECTOR(*result)[j++] = orig[i];
------------------
| | 60| 199M|#define VECTOR(v) ((v).stor_begin)
------------------
107| 199M| }
108| 158k| }
109| 986k| VECTOR(*result)[newlen] = 0;
------------------
| | 60| 986k|#define VECTOR(v) ((v).stor_begin)
------------------
110| |
111| 986k| return IGRAPH_SUCCESS;
112| 986k|}
dot.c:fprint_integral_or_precise:
117| 100k|static igraph_error_t fprint_integral_or_precise(FILE *file, igraph_real_t x, igraph_vector_char_t *buf) {
118| 100k| if (fabs(x) <= IGRAPH_MAX_EXACT_REAL && floor(x) == x) {
------------------
| | 35| 200k|#define IGRAPH_MAX_EXACT_REAL ((double)(1LL << DBL_MANT_DIG))
------------------
| Branch (118:9): [True: 5.47k, False: 94.7k]
| Branch (118:45): [True: 4.78k, False: 693]
------------------
119| | /* write exactly representable integral values in standard integer notation;
120| | * the above conditional skips +-Inf and NaN */
121| 4.78k| CHECK(fprintf(file, "%.f", x));
------------------
| | 37| 4.78k|#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.78k]
| | | Branch (37:116): [Folded, False: 4.78k]
| | ------------------
------------------
122| 95.4k| } else {
123| | /* write as precise float and quote if necessary */
124| 95.4k| char str[50]; /* large enough to hold any precisely printed real */
125| 95.4k| CHECK(igraph_real_snprintf_precise(str, sizeof(str) / sizeof(str[0]), x));
------------------
| | 37| 95.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:42): [True: 0, False: 95.4k]
| | | Branch (37:116): [Folded, False: 95.4k]
| | ------------------
------------------
126| 95.4k| IGRAPH_CHECK(dot_escape(str, buf));
------------------
| | 656| 95.4k| do { \
| | 657| 95.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 95.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 95.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 95.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| 95.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 95.4k]
| | ------------------
------------------
127| 95.4k| CHECK(fputs(VECTOR(*buf), file));
------------------
| | 37| 95.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:42): [True: 0, False: 95.4k]
| | | Branch (37:116): [Folded, False: 95.4k]
| | ------------------
------------------
128| 95.4k| }
129| 100k| return IGRAPH_SUCCESS;
130| 100k|}
igraph_gml_tree_init_integer:
31| 756k| igraph_int_t value) {
32| |
33| 756k| igraph_int_t *p;
34| |
35| 756k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 756k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 756k| do { \
| | | | 657| 756k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 756k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 756k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 756k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 756k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 756k]
| | | | ------------------
| | ------------------
| | 47| 756k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 756k| do { \
| | | | 604| 756k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 756k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 756k| * incorrect destructor function with the pointer */ \
| | | | 607| 756k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 756k]
| | | | ------------------
| | | | 608| 756k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 756k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 756k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 756k]
| | ------------------
------------------
36| 756k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 756k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 756k| do { \
| | | | 657| 756k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 756k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 756k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 756k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 756k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 756k]
| | | | ------------------
| | ------------------
| | 115| 756k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 756k| do { \
| | | | 604| 756k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 756k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 756k| * incorrect destructor function with the pointer */ \
| | | | 607| 756k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 756k]
| | | | ------------------
| | | | 608| 756k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 756k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 756k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 756k]
| | ------------------
------------------
37| 756k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 756k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 756k| do { \
| | | | 657| 756k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 756k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 756k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 756k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 756k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 756k]
| | | | ------------------
| | ------------------
| | 47| 756k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 756k| do { \
| | | | 604| 756k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 756k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 756k| * incorrect destructor function with the pointer */ \
| | | | 607| 756k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 756k]
| | | | ------------------
| | | | 608| 756k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 756k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 756k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 756k]
| | ------------------
------------------
38| 756k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 756k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 756k| do { \
| | | | 657| 756k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 756k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 756k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 756k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 756k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 756k]
| | | | ------------------
| | ------------------
| | 120| 756k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 756k| do { \
| | | | 604| 756k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 756k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 756k| * incorrect destructor function with the pointer */ \
| | | | 607| 756k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 756k]
| | | | ------------------
| | | | 608| 756k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 756k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 756k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 756k]
| | ------------------
------------------
39| |
40| | /* names */
41| 756k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 756k|#define VECTOR(v) ((v).stor_begin)
------------------
42| |
43| | /* line number */
44| 756k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 756k|#define VECTOR(v) ((v).stor_begin)
------------------
45| |
46| | /* types */
47| 756k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_INTEGER;
------------------
| | 60| 756k|#define VECTOR(v) ((v).stor_begin)
------------------
48| |
49| | /* children */
50| 756k| p = IGRAPH_CALLOC(1, igraph_int_t);
------------------
| | 33| 756k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.51M| (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: 756k, Folded]
| | | | ------------------
| | ------------------
------------------
51| 756k| IGRAPH_CHECK_OOM(p, "Cannot create integer GML tree node.");
------------------
| | 709| 756k| do { \
| | 710| 756k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 756k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 756k]
| | | | ------------------
| | ------------------
| | 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| 756k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 756k]
| | ------------------
------------------
52| 756k| *p = value;
53| 756k| VECTOR(t->children)[0] = p;
------------------
| | 60| 756k|#define VECTOR(v) ((v).stor_begin)
------------------
54| |
55| 756k| IGRAPH_FINALLY_CLEAN(4);
56| 756k| return IGRAPH_SUCCESS;
57| 756k|}
igraph_gml_tree_init_real:
62| 906| igraph_real_t value) {
63| |
64| 906| igraph_real_t *p;
65| |
66| 906| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 906| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 906| do { \
| | | | 657| 906| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 906| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 906| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 906]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 906| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 906]
| | | | ------------------
| | ------------------
| | 47| 906| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 906| do { \
| | | | 604| 906| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 906| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 906| * incorrect destructor function with the pointer */ \
| | | | 607| 906| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 906]
| | | | ------------------
| | | | 608| 906| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 906| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 906]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 906]
| | ------------------
------------------
67| 906| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 906| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 906| do { \
| | | | 657| 906| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 906| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 906| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 906]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 906| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 906]
| | | | ------------------
| | ------------------
| | 115| 906| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 906| do { \
| | | | 604| 906| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 906| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 906| * incorrect destructor function with the pointer */ \
| | | | 607| 906| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 906]
| | | | ------------------
| | | | 608| 906| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 906| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 906]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 906]
| | ------------------
------------------
68| 906| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 906| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 906| do { \
| | | | 657| 906| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 906| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 906| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 906]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 906| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 906]
| | | | ------------------
| | ------------------
| | 47| 906| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 906| do { \
| | | | 604| 906| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 906| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 906| * incorrect destructor function with the pointer */ \
| | | | 607| 906| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 906]
| | | | ------------------
| | | | 608| 906| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 906| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 906]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 906]
| | ------------------
------------------
69| 906| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 906| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 906| do { \
| | | | 657| 906| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 906| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 906| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 906]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 906| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 906]
| | | | ------------------
| | ------------------
| | 120| 906| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 906| do { \
| | | | 604| 906| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 906| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 906| * incorrect destructor function with the pointer */ \
| | | | 607| 906| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 906]
| | | | ------------------
| | | | 608| 906| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 906| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 906]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 906]
| | ------------------
------------------
70| |
71| | /* names */
72| 906| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 906|#define VECTOR(v) ((v).stor_begin)
------------------
73| |
74| | /* line number */
75| 906| VECTOR(t->lines)[0] = line;
------------------
| | 60| 906|#define VECTOR(v) ((v).stor_begin)
------------------
76| |
77| | /* types */
78| 906| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_REAL;
------------------
| | 60| 906|#define VECTOR(v) ((v).stor_begin)
------------------
79| |
80| | /* children */
81| 906| p = IGRAPH_CALLOC(1, igraph_real_t);
------------------
| | 33| 906|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.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: 906, Folded]
| | | | ------------------
| | ------------------
------------------
82| 906| IGRAPH_CHECK_OOM(p, "Cannot create real GML tree node.");
------------------
| | 709| 906| do { \
| | 710| 906| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 906| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 906]
| | | | ------------------
| | ------------------
| | 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| 906| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 906]
| | ------------------
------------------
83| 906| *p = value;
84| 906| VECTOR(t->children)[0] = p;
------------------
| | 60| 906|#define VECTOR(v) ((v).stor_begin)
------------------
85| |
86| 906| IGRAPH_FINALLY_CLEAN(4);
87| 906| return IGRAPH_SUCCESS;
88| 906|}
igraph_gml_tree_init_string:
93| 362k| const char *value) {
94| |
95| 362k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 362k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 47| 362k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 362k| do { \
| | | | 604| 362k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 362k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 362k| * incorrect destructor function with the pointer */ \
| | | | 607| 362k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 362k]
| | | | ------------------
| | | | 608| 362k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 362k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 362k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 362k]
| | ------------------
------------------
96| 362k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 362k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 115| 362k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 362k| do { \
| | | | 604| 362k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 362k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 362k| * incorrect destructor function with the pointer */ \
| | | | 607| 362k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 362k]
| | | | ------------------
| | | | 608| 362k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 362k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 362k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 362k]
| | ------------------
------------------
97| 362k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 362k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 47| 362k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 362k| do { \
| | | | 604| 362k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 362k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 362k| * incorrect destructor function with the pointer */ \
| | | | 607| 362k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 362k]
| | | | ------------------
| | | | 608| 362k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 362k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 362k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 362k]
| | ------------------
------------------
98| 362k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 362k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 362k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 362k| do { \
| | | | 604| 362k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 362k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 362k| * incorrect destructor function with the pointer */ \
| | | | 607| 362k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 362k]
| | | | ------------------
| | | | 608| 362k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 362k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 362k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 362k]
| | ------------------
------------------
99| |
100| | /* names */
101| 362k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 362k|#define VECTOR(v) ((v).stor_begin)
------------------
102| |
103| | /* line number */
104| 362k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 362k|#define VECTOR(v) ((v).stor_begin)
------------------
105| |
106| | /* types */
107| 362k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_STRING;
------------------
| | 60| 362k|#define VECTOR(v) ((v).stor_begin)
------------------
108| |
109| | /* children */
110| 362k| VECTOR(t->children)[0] = (void*) value;
------------------
| | 60| 362k|#define VECTOR(v) ((v).stor_begin)
------------------
111| |
112| 362k| IGRAPH_FINALLY_CLEAN(4);
113| 362k| return IGRAPH_SUCCESS;
114| 362k|}
igraph_gml_tree_init_tree:
119| 388k| igraph_gml_tree_t *value) {
120| |
121| 388k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 388k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 388k| do { \
| | | | 657| 388k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 388k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 388k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 388k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 388k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 388k]
| | | | ------------------
| | ------------------
| | 47| 388k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 388k| do { \
| | | | 604| 388k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 388k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 388k| * incorrect destructor function with the pointer */ \
| | | | 607| 388k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 388k]
| | | | ------------------
| | | | 608| 388k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 388k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 388k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 388k]
| | ------------------
------------------
122| 388k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 388k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 388k| do { \
| | | | 657| 388k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 388k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 388k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 388k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 388k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 388k]
| | | | ------------------
| | ------------------
| | 115| 388k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 388k| do { \
| | | | 604| 388k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 388k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 388k| * incorrect destructor function with the pointer */ \
| | | | 607| 388k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 388k]
| | | | ------------------
| | | | 608| 388k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 388k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 388k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 388k]
| | ------------------
------------------
123| 388k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 388k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 388k| do { \
| | | | 657| 388k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 388k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 388k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 388k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 388k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 388k]
| | | | ------------------
| | ------------------
| | 47| 388k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 388k| do { \
| | | | 604| 388k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 388k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 388k| * incorrect destructor function with the pointer */ \
| | | | 607| 388k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 388k]
| | | | ------------------
| | | | 608| 388k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 388k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 388k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 388k]
| | ------------------
------------------
124| 388k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 388k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 388k| do { \
| | | | 657| 388k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 388k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 388k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 388k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 388k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 388k]
| | | | ------------------
| | ------------------
| | 120| 388k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 388k| do { \
| | | | 604| 388k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 388k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 388k| * incorrect destructor function with the pointer */ \
| | | | 607| 388k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 388k]
| | | | ------------------
| | | | 608| 388k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 388k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 388k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 388k]
| | ------------------
------------------
125| |
126| | /* names */
127| 388k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 388k|#define VECTOR(v) ((v).stor_begin)
------------------
128| |
129| | /* line number */
130| 388k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 388k|#define VECTOR(v) ((v).stor_begin)
------------------
131| |
132| | /* types */
133| 388k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_TREE;
------------------
| | 60| 388k|#define VECTOR(v) ((v).stor_begin)
------------------
134| |
135| | /* children */
136| 388k| VECTOR(t->children)[0] = value;
------------------
| | 60| 388k|#define VECTOR(v) ((v).stor_begin)
------------------
137| |
138| 388k| IGRAPH_FINALLY_CLEAN(4);
139| 388k| return IGRAPH_SUCCESS;
140| |
141| 388k|}
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.23M| 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| 391k|void igraph_gml_tree_destroy(igraph_gml_tree_t *t) {
172| |
173| 391k| igraph_int_t i, n = igraph_vector_ptr_size(&t->children);
174| 1.90M| for (i = 0; i < n; i++) {
------------------
| Branch (174:17): [True: 1.50M, False: 391k]
------------------
175| 1.50M| igraph_i_gml_tree_type_t type = (igraph_i_gml_tree_type_t) VECTOR(t->types)[i];
------------------
| | 60| 1.50M|#define VECTOR(v) ((v).stor_begin)
------------------
176| 1.50M| switch (type) {
------------------
| Branch (176:17): [True: 1.50M, False: 0]
------------------
177| 388k| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (177:9): [True: 388k, False: 1.12M]
------------------
178| 388k| igraph_gml_tree_destroy(VECTOR(t->children)[i]);
------------------
| | 60| 388k|#define VECTOR(v) ((v).stor_begin)
------------------
179| 388k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 388k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
180| 388k| break;
181| 756k| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (181:9): [True: 756k, False: 752k]
------------------
182| 756k| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 756k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
183| 756k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 756k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
184| 756k| break;
185| 906| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (185:9): [True: 906, False: 1.50M]
------------------
186| 906| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 906|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
187| 906| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 906|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
188| 906| break;
189| 362k| case IGRAPH_I_GML_TREE_STRING:
------------------
| Branch (189:9): [True: 362k, False: 1.14M]
------------------
190| 362k| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 362k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
191| 362k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 362k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
192| 362k| break;
193| 0| case IGRAPH_I_GML_TREE_DELETED:
------------------
| Branch (193:9): [True: 0, False: 1.50M]
------------------
194| 0| break;
195| 1.50M| }
196| 1.50M| }
197| 391k| igraph_vector_ptr_destroy(&t->names);
198| 391k| igraph_vector_char_destroy(&t->types);
199| 391k| igraph_vector_ptr_destroy(&t->children);
200| 391k| igraph_vector_int_destroy(&t->lines);
201| | IGRAPH_FREE(t);
------------------
| | 36| 391k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
202| 391k|}
igraph_gml_tree_length:
204| 3.77M|igraph_int_t igraph_gml_tree_length(const igraph_gml_tree_t *t) {
205| 3.77M| return igraph_vector_ptr_size(&t->names);
206| 3.77M|}
igraph_gml_tree_find:
210| 744k|) {
211| 744k| igraph_int_t size = igraph_vector_ptr_size(&t->names);
212| 1.10M| while ( from < size && (! VECTOR(t->names)[from] ||
------------------
| | 60| 1.10M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (212:13): [True: 1.10M, False: 0]
| Branch (212:29): [True: 0, False: 1.10M]
------------------
213| 1.10M| strcmp(VECTOR(t->names)[from], name)) ) {
------------------
| | 60| 1.10M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (213:29): [True: 361k, False: 744k]
------------------
214| 361k| from++;
215| 361k| }
216| |
217| 744k| if (from == size) {
------------------
| Branch (217:9): [True: 0, False: 744k]
------------------
218| 0| from = -1;
219| 0| }
220| 744k| return from;
221| 744k|}
igraph_gml_tree_type:
234| 1.91M|igraph_i_gml_tree_type_t igraph_gml_tree_type(const igraph_gml_tree_t *t, igraph_int_t pos) {
235| 1.91M| return (igraph_i_gml_tree_type_t) VECTOR(t->types)[pos];
------------------
| | 60| 1.91M|#define VECTOR(v) ((v).stor_begin)
------------------
236| 1.91M|}
igraph_gml_tree_name:
238| 2.99M|const char *igraph_gml_tree_name(const igraph_gml_tree_t *t, igraph_int_t pos) {
239| 2.99M| return VECTOR(t->names)[pos];
------------------
| | 60| 2.99M|#define VECTOR(v) ((v).stor_begin)
------------------
240| 2.99M|}
igraph_gml_tree_get_integer:
247| 822k| igraph_int_t pos) {
248| 822k| igraph_int_t *i = VECTOR(t->children)[pos];
------------------
| | 60| 822k|#define VECTOR(v) ((v).stor_begin)
------------------
249| 822k| return *i;
250| 822k|}
igraph_gml_tree_get_real:
253| 906| igraph_int_t pos) {
254| 906| igraph_real_t *d = VECTOR(t->children)[pos];
------------------
| | 60| 906|#define VECTOR(v) ((v).stor_begin)
------------------
255| 906| return *d;
256| 906|}
igraph_gml_tree_get_string:
259| 359k| igraph_int_t pos) {
260| 359k| const char *s = VECTOR(t->children)[pos];
------------------
| | 60| 359k|#define VECTOR(v) ((v).stor_begin)
------------------
261| 359k| return s;
262| 359k|}
igraph_gml_tree_get_tree:
265| 773k| igraph_int_t pos) {
266| 773k| igraph_gml_tree_t *tree = VECTOR(t->children)[pos];
------------------
| | 60| 773k|#define VECTOR(v) ((v).stor_begin)
------------------
267| 773k| return tree;
268| 773k|}
igraph_i_gml_parsedata_init:
212| 3.17k|igraph_error_t igraph_i_gml_parsedata_init(igraph_i_gml_parsedata_t *context) {
213| 3.17k| context->depth = 0;
214| 3.17k| context->scanner = NULL;
215| 3.17k| context->tree = NULL;
216| 3.17k| context->errmsg[0] = '\0';
217| 3.17k| context->igraph_errno = IGRAPH_SUCCESS;
218| |
219| 3.17k| return IGRAPH_SUCCESS;
220| 3.17k|}
igraph_i_gml_parsedata_destroy:
222| 3.17k|void igraph_i_gml_parsedata_destroy(igraph_i_gml_parsedata_t *context) {
223| 3.17k| if (context->tree != NULL) {
------------------
| Branch (223:9): [True: 3.17k, False: 0]
------------------
224| 3.17k| igraph_gml_tree_destroy(context->tree);
225| 3.17k| context->tree = NULL;
226| 3.17k| }
227| |
228| 3.17k| if (context->scanner != NULL) {
------------------
| Branch (228:9): [True: 3.17k, False: 0]
------------------
229| 3.17k| (void) igraph_gml_yylex_destroy(context->scanner);
230| | context->scanner = NULL;
231| 3.17k| }
232| 3.17k|}
igraph_read_graph_gml:
386| 3.17k|igraph_error_t igraph_read_graph_gml(igraph_t *graph, FILE *instream) {
387| |
388| 3.17k| igraph_int_t i;
389| 3.17k| igraph_int_t no_of_nodes = 0, no_of_edges = 0;
390| 3.17k| igraph_int_t node_no;
391| 3.17k| igraph_trie_t trie;
392| 3.17k| igraph_vector_int_t edges;
393| 3.17k| igraph_bool_t directed = IGRAPH_UNDIRECTED;
394| 3.17k| igraph_bool_t has_directed = false;
395| 3.17k| igraph_gml_tree_t *gtree;
396| 3.17k| igraph_int_t gidx;
397| 3.17k| igraph_trie_t vattrnames;
398| 3.17k| igraph_trie_t eattrnames;
399| 3.17k| igraph_trie_t gattrnames;
400| 3.17k| igraph_attribute_record_list_t gattrs, vattrs, eattrs;
401| 3.17k| igraph_attribute_record_list_t *attrs[3];
402| 3.17k| igraph_int_t edgeptr = 0;
403| 3.17k| igraph_i_gml_parsedata_t context;
404| 3.17k| igraph_bool_t entity_warned = false; /* used to warn at most once about unsupported entities */
405| |
406| 3.17k| attrs[0] = &gattrs; attrs[1] = &vattrs; attrs[2] = &eattrs;
407| |
408| 3.17k| IGRAPH_CHECK(igraph_i_gml_parsedata_init(&context));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
409| 3.17k| IGRAPH_FINALLY(igraph_i_gml_parsedata_destroy, &context);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
410| |
411| 3.17k| igraph_gml_yylex_init_extra(&context, &context.scanner);
412| |
413| 3.17k| igraph_gml_yyset_in(instream, context.scanner);
414| |
415| | /* Protect 'context' from being destroyed before returning from yyparse() */
416| 3.17k| IGRAPH_FINALLY_ENTER();
417| 3.17k| int err = igraph_gml_yyparse(&context);
418| 3.17k| IGRAPH_FINALLY_EXIT();
419| 3.17k| switch (err) {
420| 3.17k| case 0: /* success */
------------------
| Branch (420:5): [True: 3.17k, False: 0]
------------------
421| 3.17k| break;
422| 0| case 1: /* parse error */
------------------
| Branch (422:5): [True: 0, False: 3.17k]
------------------
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.17k]
------------------
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.17k]
------------------
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.17k| }
442| |
443| | /* Check version, if present, integer and not '1' then ignored */
444| 3.17k| i = igraph_gml_tree_find(context.tree, "Version", 0);
445| 3.17k| if (i >= 0 &&
------------------
| Branch (445:9): [True: 3.17k, False: 0]
------------------
446| 3.17k| igraph_gml_tree_type(context.tree, i) == IGRAPH_I_GML_TREE_INTEGER &&
------------------
| Branch (446:9): [True: 3.17k, False: 0]
------------------
447| 3.17k| igraph_gml_tree_get_integer(context.tree, i) != 1) {
------------------
| Branch (447:9): [True: 0, False: 3.17k]
------------------
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.17k| gidx = igraph_gml_tree_find(context.tree, "graph", 0);
455| 3.17k| if (gidx == -1) {
------------------
| Branch (455:9): [True: 0, False: 3.17k]
------------------
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.17k| if (igraph_gml_tree_type(context.tree, gidx) !=
------------------
| Branch (458:9): [True: 0, False: 3.17k]
------------------
459| 3.17k| 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.17k| gtree = igraph_gml_tree_get_tree(context.tree, gidx);
464| |
465| 3.17k| IGRAPH_CHECK(igraph_attribute_record_list_init(&gattrs, 0));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
466| 3.17k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &gattrs);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
467| 3.17k| IGRAPH_CHECK(igraph_attribute_record_list_init(&vattrs, 0));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
468| 3.17k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &vattrs);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
469| 3.17k| IGRAPH_CHECK(igraph_attribute_record_list_init(&eattrs, 0));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
470| 3.17k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &eattrs);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
471| |
472| 3.17k| IGRAPH_TRIE_INIT_FINALLY(&trie, 0);
------------------
| | 55| 3.17k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 56| 3.17k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.17k]
| | ------------------
------------------
473| 3.17k| IGRAPH_TRIE_INIT_FINALLY(&vattrnames, 0);
------------------
| | 55| 3.17k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 56| 3.17k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.17k]
| | ------------------
------------------
474| 3.17k| IGRAPH_TRIE_INIT_FINALLY(&eattrnames, 0);
------------------
| | 55| 3.17k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 56| 3.17k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.17k]
| | ------------------
------------------
475| 3.17k| IGRAPH_TRIE_INIT_FINALLY(&gattrnames, 0);
------------------
| | 55| 3.17k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 56| 3.17k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.17k]
| | ------------------
------------------
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.17k| node_no = 0;
494| 392k| for (i = 0; i < igraph_gml_tree_length(gtree); i++) {
------------------
| Branch (494:17): [True: 389k, False: 3.17k]
------------------
495| 389k| const char *name = igraph_gml_tree_name(gtree, i);
496| 389k| if (!strcmp(name, "node")) {
------------------
| Branch (496:13): [True: 32.9k, False: 356k]
------------------
497| 32.9k| igraph_gml_tree_t *node;
498| 32.9k| igraph_bool_t hasid;
499| 32.9k| node_no++;
500| 32.9k| no_of_nodes++;
501| 32.9k| if (igraph_gml_tree_type(gtree, i) != IGRAPH_I_GML_TREE_TREE) {
------------------
| Branch (501:17): [True: 0, False: 32.9k]
------------------
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| 32.9k| node = igraph_gml_tree_get_tree(gtree, i);
506| 32.9k| hasid = false;
507| 83.6k| for (igraph_int_t j = 0; j < igraph_gml_tree_length(node); j++) {
------------------
| Branch (507:38): [True: 50.7k, False: 32.9k]
------------------
508| 50.7k| const char *name = igraph_gml_tree_name(node, j);
509| 50.7k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, j);
510| 50.7k| IGRAPH_CHECK(create_or_update_attribute(name, type, &vattrnames, &vattrs));
------------------
| | 656| 50.7k| do { \
| | 657| 50.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 50.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 50.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 50.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| 50.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 50.7k]
| | ------------------
------------------
511| | /* check id */
512| 50.7k| if (!strcmp(name, "id")) {
------------------
| Branch (512:21): [True: 32.9k, False: 17.8k]
------------------
513| 32.9k| igraph_int_t id, trie_id;
514| 32.9k| igraph_int_t trie_size = igraph_trie_size(&trie);
515| 32.9k| if (hasid) {
------------------
| Branch (515:25): [True: 0, False: 32.9k]
------------------
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| 32.9k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (523:25): [True: 0, False: 32.9k]
------------------
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| 32.9k| id = igraph_gml_tree_get_integer(node, j);
528| 32.9k| IGRAPH_CHECK(igraph_trie_get(&trie, strid(id, ""), &trie_id));
------------------
| | 656| 32.9k| do { \
| | 657| 32.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.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| 32.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.9k]
| | ------------------
------------------
529| 32.9k| if (trie_id != trie_size) {
------------------
| Branch (529:25): [True: 0, False: 32.9k]
------------------
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| 32.9k| hasid = true;
535| 32.9k| }
536| 50.7k| }
537| 32.9k| if (!hasid) {
------------------
| Branch (537:17): [True: 0, False: 32.9k]
------------------
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| 356k| } else if (!strcmp(name, "edge")) {
------------------
| Branch (543:20): [True: 352k, False: 3.90k]
------------------
544| 352k| igraph_gml_tree_t *edge;
545| 352k| igraph_bool_t has_source = false, has_target = false;
546| 352k| no_of_edges++;
547| 352k| if (igraph_gml_tree_type(gtree, i) != IGRAPH_I_GML_TREE_TREE) {
------------------
| Branch (547:17): [True: 0, False: 352k]
------------------
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| 352k| edge = igraph_gml_tree_get_tree(gtree, i);
552| 1.41M| for (igraph_int_t j = 0; j < igraph_gml_tree_length(edge); j++) {
------------------
| Branch (552:38): [True: 1.05M, False: 352k]
------------------
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: 352k, False: 706k]
------------------
556| 352k| if (has_source) {
------------------
| Branch (556:25): [True: 0, False: 352k]
------------------
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| 352k| has_source = true;
566| 352k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (566:25): [True: 0, False: 352k]
------------------
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| 706k| } else if (!strcmp(name, "target")) {
------------------
| Branch (571:28): [True: 352k, False: 354k]
------------------
572| 352k| if (has_target) {
------------------
| Branch (572:25): [True: 0, False: 352k]
------------------
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| 352k| has_target = true;
579| 352k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (579:25): [True: 0, False: 352k]
------------------
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| 354k| } else {
585| 354k| IGRAPH_CHECK(create_or_update_attribute(name, type, &eattrnames, &eattrs));
------------------
| | 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]
| | ------------------
------------------
586| 354k| }
587| 1.05M| } /* for */
588| 352k| if (!has_source) {
------------------
| Branch (588:17): [True: 0, False: 352k]
------------------
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| 352k| if (!has_target) {
------------------
| Branch (592:17): [True: 0, False: 352k]
------------------
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| 352k| } else if (! strcmp(name, "directed")) {
------------------
| Branch (596:20): [True: 3.17k, False: 726]
------------------
597| | /* Set directedness of graph. */
598| 3.17k| if (has_directed) {
------------------
| Branch (598:17): [True: 0, False: 3.17k]
------------------
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.17k| if (igraph_gml_tree_type(gtree, i) == IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (604:17): [True: 3.17k, False: 0]
------------------
605| 3.17k| igraph_int_t dir = igraph_gml_tree_get_integer(gtree, i);
606| 3.17k| if (dir != 0 && dir != 1) {
------------------
| Branch (606:21): [True: 133, False: 3.04k]
| Branch (606:33): [True: 0, False: 133]
------------------
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.17k| if (dir) {
------------------
| Branch (611:21): [True: 133, False: 3.04k]
------------------
612| 133| directed = IGRAPH_DIRECTED;
613| 133| }
614| 3.17k| has_directed = true;
615| 3.17k| } 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.17k| } else {
620| | /* Add the rest of items as graph attributes. */
621| 726| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(gtree, i);
622| 726| IGRAPH_CHECK(create_or_update_attribute(name, type, &gattrnames, &gattrs));
------------------
| | 656| 726| do { \
| | 657| 726| igraph_error_t igraph_i_ret = (expr); \
| | 658| 726| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 726| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 726]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 726| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 726]
| | ------------------
------------------
623| 726| }
624| 389k| }
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.17k| IGRAPH_ASSERT(igraph_trie_size(&trie) == no_of_nodes);
------------------
| | 924| 3.17k| do { \
| | 925| 3.17k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.17k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.17k]
| | ------------------
------------------
630| |
631| | /* Now we allocate the vectors and strvectors for the attributes */
632| 3.17k| IGRAPH_CHECK(allocate_attributes(&vattrs, no_of_nodes, "vertex"));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
633| 3.17k| IGRAPH_CHECK(allocate_attributes(&eattrs, no_of_edges, "edge"));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
634| 3.17k| IGRAPH_CHECK(allocate_attributes(&gattrs, 1, "graph"));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
635| |
636| | /* Add edges, edge attributes and vertex attributes */
637| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, no_of_edges * 2);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
638| 3.17k| node_no = 0;
639| 392k| for (i = 0; i < igraph_gml_tree_length(gtree); i++) {
------------------
| Branch (639:17): [True: 389k, False: 3.17k]
------------------
640| 389k| const char *name;
641| 389k| name = igraph_gml_tree_name(gtree, i);
642| 389k| if (!strcmp(name, "node")) {
------------------
| Branch (642:13): [True: 32.9k, False: 356k]
------------------
643| 32.9k| igraph_gml_tree_t *node = igraph_gml_tree_get_tree(gtree, i);
644| 32.9k| igraph_int_t iidx = igraph_gml_tree_find(node, "id", 0);
645| 32.9k| igraph_int_t trie_id;
646| 32.9k| const char *sid;
647| 32.9k| node_no++;
648| 32.9k| if (iidx < 0) {
------------------
| Branch (648:17): [True: 0, False: 32.9k]
------------------
649| | /* Isolated node with no id field, use n-prefixed generated id */
650| 0| sid = strid(node_no, "n");
651| 32.9k| } else {
652| 32.9k| sid = strid(igraph_gml_tree_get_integer(node, iidx), "");
653| 32.9k| }
654| 32.9k| IGRAPH_CHECK(igraph_trie_get(&trie, sid, &trie_id));
------------------
| | 656| 32.9k| do { \
| | 657| 32.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.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| 32.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.9k]
| | ------------------
------------------
655| 83.6k| for (igraph_int_t j = 0; j < igraph_gml_tree_length(node); j++) {
------------------
| Branch (655:38): [True: 50.7k, False: 32.9k]
------------------
656| 50.7k| const char *aname = igraph_gml_tree_name(node, j);
657| 50.7k| igraph_attribute_record_t *atrec;
658| 50.7k| igraph_attribute_type_t type;
659| 50.7k| igraph_int_t ai;
660| 50.7k| IGRAPH_CHECK(igraph_trie_get(&vattrnames, aname, &ai));
------------------
| | 656| 50.7k| do { \
| | 657| 50.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 50.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 50.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 50.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| 50.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 50.7k]
| | ------------------
------------------
661| 50.7k| atrec = igraph_attribute_record_list_get_ptr(&vattrs, ai);
662| 50.7k| type = atrec->type;
663| 50.7k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (663:21): [True: 39.1k, False: 11.6k]
------------------
664| 39.1k| VECTOR(*atrec->value.as_vector)[trie_id] = igraph_i_gml_toreal(node, j);
------------------
| | 60| 39.1k|#define VECTOR(v) ((v).stor_begin)
------------------
665| 39.1k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (665:28): [True: 11.6k, False: 0]
------------------
666| 11.6k| igraph_strvector_t *v = atrec->value.as_strvector;
667| 11.6k| const char *value = igraph_i_gml_tostring(node, j);
668| 11.6k| if (needs_coding(value)) {
------------------
| Branch (668:25): [True: 5.58k, False: 6.05k]
------------------
669| 5.58k| char *value_decoded;
670| 5.58k| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 656| 5.58k| do { \
| | 657| 5.58k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.58k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.58k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.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| 5.58k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.58k]
| | ------------------
------------------
671| 5.58k| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 5.58k| do { \
| | 604| 5.58k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.58k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.58k| * incorrect destructor function with the pointer */ \
| | 607| 5.58k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.58k]
| | ------------------
| | 608| 5.58k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.58k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.58k]
| | ------------------
------------------
672| 5.58k| IGRAPH_CHECK(igraph_strvector_set(v, trie_id, value_decoded));
------------------
| | 656| 5.58k| do { \
| | 657| 5.58k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.58k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.58k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.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| 5.58k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.58k]
| | ------------------
------------------
673| 5.58k| IGRAPH_FREE(value_decoded);
------------------
| | 36| 5.58k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
674| 5.58k| IGRAPH_FINALLY_CLEAN(1);
675| 6.05k| } else {
676| 6.05k| IGRAPH_CHECK(igraph_strvector_set(v, trie_id, value));
------------------
| | 656| 6.05k| do { \
| | 657| 6.05k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.05k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.05k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.05k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.05k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.05k]
| | ------------------
------------------
677| 6.05k| }
678| 11.6k| } else {
679| | /* Ignored composite attribute */
680| 0| }
681| 50.7k| }
682| 356k| } else if (!strcmp(name, "edge")) {
------------------
| Branch (682:20): [True: 352k, False: 3.90k]
------------------
683| 352k| igraph_gml_tree_t *edge;
684| 352k| igraph_int_t from, to, fromidx = 0, toidx = 0;
685| 352k| edge = igraph_gml_tree_get_tree(gtree, i);
686| 1.41M| for (igraph_int_t j = 0; j < igraph_gml_tree_length(edge); j++) {
------------------
| Branch (686:38): [True: 1.05M, False: 352k]
------------------
687| 1.05M| const char *aname = igraph_gml_tree_name(edge, j);
688| 1.05M| if (!strcmp(aname, "source")) {
------------------
| Branch (688:21): [True: 352k, False: 706k]
------------------
689| 352k| fromidx = igraph_gml_tree_find(edge, "source", 0);
690| 706k| } else if (!strcmp(aname, "target")) {
------------------
| Branch (690:28): [True: 352k, False: 354k]
------------------
691| 352k| toidx = igraph_gml_tree_find(edge, "target", 0);
692| 354k| } else {
693| 354k| igraph_int_t edgeid = edgeptr / 2;
694| 354k| igraph_int_t ai;
695| 354k| igraph_attribute_record_t *atrec;
696| 354k| igraph_attribute_type_t type;
697| 354k| IGRAPH_CHECK(igraph_trie_get(&eattrnames, aname, &ai));
------------------
| | 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]
| | ------------------
------------------
698| 354k| atrec = igraph_attribute_record_list_get_ptr(&eattrs, ai);
699| 354k| type = atrec->type;
700| 354k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (700:25): [True: 6.24k, False: 347k]
------------------
701| 6.24k| VECTOR(*atrec->value.as_vector)[edgeid] = igraph_i_gml_toreal(edge, j);
------------------
| | 60| 6.24k|#define VECTOR(v) ((v).stor_begin)
------------------
702| 347k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (702:32): [True: 347k, False: 0]
------------------
703| 347k| igraph_strvector_t *v = atrec->value.as_strvector;
704| 347k| const char *value = igraph_i_gml_tostring(edge, j);
705| 347k| if (needs_coding(value)) {
------------------
| Branch (705:29): [True: 2.17k, False: 345k]
------------------
706| 2.17k| char *value_decoded;
707| 2.17k| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 656| 2.17k| do { \
| | 657| 2.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.17k]
| | ------------------
------------------
708| 2.17k| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 2.17k| do { \
| | 604| 2.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.17k| * incorrect destructor function with the pointer */ \
| | 607| 2.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.17k]
| | ------------------
| | 608| 2.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.17k]
| | ------------------
------------------
709| 2.17k| IGRAPH_CHECK(igraph_strvector_set(v, edgeid, value_decoded));
------------------
| | 656| 2.17k| do { \
| | 657| 2.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.17k]
| | ------------------
------------------
710| 2.17k| IGRAPH_FREE(value_decoded);
------------------
| | 36| 2.17k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
711| 2.17k| IGRAPH_FINALLY_CLEAN(1);
712| 345k| } else {
713| 345k| IGRAPH_CHECK(igraph_strvector_set(v, edgeid, value));
------------------
| | 656| 345k| do { \
| | 657| 345k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 345k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 345k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 345k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 345k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 345k]
| | ------------------
------------------
714| 345k| }
715| 347k| } else {
716| | /* Ignored composite attribute */
717| 0| }
718| 354k| }
719| 1.05M| }
720| 352k| from = igraph_gml_tree_get_integer(edge, fromidx);
721| 352k| to = igraph_gml_tree_get_integer(edge, toidx);
722| 352k| IGRAPH_CHECK(igraph_trie_check(&trie, strid(from, ""), &from));
------------------
| | 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]
| | ------------------
------------------
723| 352k| if (from < 0) {
------------------
| Branch (723:17): [True: 0, False: 352k]
------------------
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| 352k| IGRAPH_CHECK(igraph_trie_check(&trie, strid(to, ""), &to));
------------------
| | 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]
| | ------------------
------------------
728| 352k| if (to < 0) {
------------------
| Branch (728:17): [True: 0, False: 352k]
------------------
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| 352k| VECTOR(edges)[edgeptr++] = from;
------------------
| | 60| 352k|#define VECTOR(v) ((v).stor_begin)
------------------
733| 352k| VECTOR(edges)[edgeptr++] = to;
------------------
| | 60| 352k|#define VECTOR(v) ((v).stor_begin)
------------------
734| 352k| } else if (! strcmp(name, "directed")) {
------------------
| Branch (734:20): [True: 3.17k, False: 726]
------------------
735| | /* Nothing to do for 'directed' field, already handled earlier. */
736| 3.17k| } else {
737| | /* Set the rest as graph attributes */
738| 726| igraph_int_t ai;
739| 726| igraph_attribute_record_t *atrec;
740| 726| igraph_attribute_type_t type;
741| 726| IGRAPH_CHECK(igraph_trie_get(&gattrnames, name, &ai));
------------------
| | 656| 726| do { \
| | 657| 726| igraph_error_t igraph_i_ret = (expr); \
| | 658| 726| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 726| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 726]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 726| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 726]
| | ------------------
------------------
742| 726| atrec = igraph_attribute_record_list_get_ptr(&gattrs, ai);
743| 726| type = atrec->type;
744| 726| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (744:17): [True: 156, False: 570]
------------------
745| 156| VECTOR(*atrec->value.as_vector)[0] = igraph_i_gml_toreal(gtree, i);
------------------
| | 60| 156|#define VECTOR(v) ((v).stor_begin)
------------------
746| 570| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (746:24): [True: 570, False: 0]
------------------
747| 570| igraph_strvector_t *v = atrec->value.as_strvector;
748| 570| const char *value = igraph_i_gml_tostring(gtree, i);
749| 570| if (needs_coding(value)) {
------------------
| Branch (749:21): [True: 70, False: 500]
------------------
750| 70| char *value_decoded;
751| 70| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 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]
| | ------------------
------------------
752| 70| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 70| do { \
| | 604| 70| /* the following branch makes the compiler check the compatibility of \
| | 605| 70| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 70| * incorrect destructor function with the pointer */ \
| | 607| 70| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 70]
| | ------------------
| | 608| 70| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 70| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 70]
| | ------------------
------------------
753| 70| IGRAPH_CHECK(igraph_strvector_set(v, 0, value_decoded));
------------------
| | 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]
| | ------------------
------------------
754| 70| IGRAPH_FREE(value_decoded);
------------------
| | 36| 70|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
755| 70| IGRAPH_FINALLY_CLEAN(1);
756| 500| } else {
757| 500| IGRAPH_CHECK(igraph_strvector_set(v, 0, value));
------------------
| | 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]
| | ------------------
------------------
758| 500| }
759| 570| } else {
760| | /* Ignored composite attribute */
761| 0| }
762| 726| }
763| 389k| }
764| |
765| | /* Remove composite attributes that we cannot represent in igraph */
766| 3.17k| IGRAPH_CHECK(prune_unknown_attributes(&vattrs));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
767| 3.17k| IGRAPH_CHECK(prune_unknown_attributes(&eattrs));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
768| 3.17k| IGRAPH_CHECK(prune_unknown_attributes(&gattrs));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
769| |
770| 3.17k| igraph_trie_destroy(&trie);
771| 3.17k| igraph_trie_destroy(&gattrnames);
772| 3.17k| igraph_trie_destroy(&vattrnames);
773| 3.17k| igraph_trie_destroy(&eattrnames);
774| 3.17k| IGRAPH_FINALLY_CLEAN(4);
775| |
776| 3.17k| IGRAPH_CHECK(igraph_empty_attrs(graph, 0, directed, &gattrs));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
777| 3.17k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
778| 3.17k| IGRAPH_CHECK(igraph_add_vertices(graph, no_of_nodes, &vattrs));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
779| 3.17k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, &eattrs));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
780| 3.17k| IGRAPH_FINALLY_CLEAN(1); /* do not destroy 'graph', just pop it from the stack */
781| |
782| 3.17k| igraph_vector_int_destroy(&edges);
783| 3.17k| igraph_attribute_record_list_destroy(&eattrs);
784| 3.17k| igraph_attribute_record_list_destroy(&vattrs);
785| 3.17k| igraph_attribute_record_list_destroy(&gattrs);
786| 3.17k| igraph_i_gml_parsedata_destroy(&context);
787| 3.17k| IGRAPH_FINALLY_CLEAN(5);
788| |
789| 3.17k| return IGRAPH_SUCCESS;
790| 3.17k|}
igraph_write_graph_gml:
932| 3.17k| const igraph_vector_t *id, const char *creator) {
933| 3.17k| igraph_strvector_t gnames, vnames, enames; /* attribute names */
934| 3.17k| igraph_vector_int_t gtypes, vtypes, etypes; /* attribute types */
935| 3.17k| igraph_int_t gattr_no, vattr_no, eattr_no; /* attribute counts */
936| 3.17k| igraph_vector_t numv;
937| 3.17k| igraph_strvector_t strv;
938| 3.17k| igraph_vector_bool_t boolv;
939| 3.17k| igraph_int_t i;
940| 3.17k| igraph_int_t no_of_nodes = igraph_vcount(graph);
941| 3.17k| 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.17k| igraph_vector_int_t warning_shown;
946| |
947| 3.17k| igraph_vector_t v_myid;
948| 3.17k| const igraph_vector_t *myid = id;
949| |
950| | /* Creator line */
951| 3.17k| if (creator == NULL) {
------------------
| Branch (951:9): [True: 0, False: 3.17k]
------------------
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.17k| } else if (creator[0] == '\0') {
------------------
| Branch (959:16): [True: 0, False: 3.17k]
------------------
960| | /* creator == "", omit Creator line */
961| 3.17k| } else {
962| 3.17k| if (needs_coding(creator)) {
------------------
| Branch (962:13): [True: 0, False: 3.17k]
------------------
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.17k| } else {
972| 3.17k| CHECK(fprintf(outstream,
------------------
| | 848| 3.17k|#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.17k]
| | | Branch (848:116): [Folded, False: 3.17k]
| | ------------------
------------------
973| 3.17k| "Creator \"%s\"\n",
974| 3.17k| creator));
975| 3.17k| }
976| 3.17k| }
977| |
978| | /* Version line */
979| 3.17k| CHECK(fprintf(outstream, "Version 1\n"));
------------------
| | 848| 3.17k|#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.17k]
| | | Branch (848:116): [Folded, False: 3.17k]
| | ------------------
------------------
980| |
981| | /* The graph */
982| 3.17k| CHECK(fprintf(outstream, "graph\n[\n"));
------------------
| | 848| 3.17k|#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.17k]
| | | Branch (848:116): [Folded, False: 3.17k]
| | ------------------
------------------
983| |
984| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
985| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
986| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
987| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
988| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
989| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
990| 3.17k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
991| 3.17k| &gnames, >ypes,
992| 3.17k| &vnames, &vtypes,
993| 3.17k| &enames, &etypes));
994| 3.17k| gattr_no = igraph_vector_int_size(>ypes);
995| 3.17k| vattr_no = igraph_vector_int_size(&vtypes);
996| 3.17k| eattr_no = igraph_vector_int_size(&etypes);
997| |
998| 3.17k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.17k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 105| 3.17k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.17k]
| | ------------------
------------------
999| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
1000| 3.17k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);
------------------
| | 109| 3.17k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 110| 3.17k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.17k]
| | ------------------
------------------
1001| |
1002| | /* Check whether there is an 'id' node attribute if the supplied is 0 */
1003| 3.17k| if (!id) {
------------------
| Branch (1003:9): [True: 3.17k, False: 0]
------------------
1004| 3.17k| igraph_bool_t found = false;
1005| 8.02k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1005:21): [True: 4.90k, False: 3.12k]
------------------
1006| 4.90k| const char *n = igraph_strvector_get(&vnames, i);
1007| 4.90k| if (!strcmp(n, "id") && VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 3.16k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1007:17): [True: 3.16k, False: 1.73k]
| Branch (1007:37): [True: 52, False: 3.11k]
------------------
1008| 52| found = true; break;
1009| 52| }
1010| 4.90k| }
1011| 3.17k| if (found) {
------------------
| Branch (1011:13): [True: 52, False: 3.12k]
------------------
1012| 52| IGRAPH_VECTOR_INIT_FINALLY(&v_myid, no_of_nodes);
------------------
| | 104| 52| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 52| do { \
| | | | 657| 52| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 52| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 52| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 52]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 52]
| | | | ------------------
| | ------------------
| | 105| 52| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 52| do { \
| | | | 604| 52| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 52| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 52| * incorrect destructor function with the pointer */ \
| | | | 607| 52| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 52]
| | | | ------------------
| | | | 608| 52| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 52| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 52]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 52]
| | ------------------
------------------
1013| 52| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, "id",
------------------
| | 656| 52| do { \
| | 657| 52| igraph_error_t igraph_i_ret = (expr); \
| | 658| 52| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 52| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 52]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 52]
| | ------------------
------------------
1014| 52| igraph_vss_all(),
1015| 52| &v_myid));
1016| 52| myid = &v_myid;
1017| 52| }
1018| 3.17k| }
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.17k| if (myid) {
------------------
| Branch (1025:9): [True: 52, False: 3.12k]
------------------
1026| 52| if (igraph_vector_size(myid) != no_of_nodes) {
------------------
| Branch (1026:13): [True: 0, False: 52]
------------------
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.14k| for (i = 0; i < no_of_nodes; ++i) {
------------------
| Branch (1029:21): [True: 2.09k, False: 49]
------------------
1030| 2.09k| igraph_real_t val = VECTOR(*myid)[i];
------------------
| | 60| 2.09k|#define VECTOR(v) ((v).stor_begin)
------------------
1031| 2.09k| igraph_real_t trunc_val = trunc(val);
1032| 2.09k| if (! (val == trunc_val && igraph_i_is_real_representable_as_integer(trunc_val))) {
------------------
| Branch (1032:20): [True: 2.09k, False: 2]
| Branch (1032:40): [True: 2.09k, 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| 2.09k| }
1042| 52| }
1043| |
1044| 3.17k| if (myid) {
------------------
| Branch (1044:9): [True: 49, False: 3.13k]
------------------
1045| 49| igraph_bool_t duplicate_free;
1046| 49| IGRAPH_CHECK(igraph_i_vector_is_duplicate_free(myid, &duplicate_free));
------------------
| | 656| 49| do { \
| | 657| 49| igraph_error_t igraph_i_ret = (expr); \
| | 658| 49| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 49| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 49| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 49]
| | ------------------
------------------
1047| 49| if (! duplicate_free) {
------------------
| Branch (1047:13): [True: 39, False: 10]
------------------
1048| 39| IGRAPH_WARNING("Duplicate id values found, ignoring supplies ids.");
------------------
| | 797| 39| do { \
| | 798| 39| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 39| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 39]
| | ------------------
------------------
1049| 39| if (myid == &v_myid) {
------------------
| Branch (1049:17): [True: 39, False: 0]
------------------
1050| 39| igraph_vector_destroy(&v_myid);
1051| 39| IGRAPH_FINALLY_CLEAN(1);
1052| 39| }
1053| 39| myid = NULL;
1054| 39| }
1055| 49| }
1056| |
1057| | /* directedness */
1058| 3.17k| CHECK(fprintf(outstream, " directed %i\n", igraph_is_directed(graph) ? 1 : 0));
------------------
| | 848| 6.35k|#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: 133, False: 3.04k]
| | | Branch (848:42): [True: 0, False: 3.17k]
| | | Branch (848:116): [Folded, False: 3.17k]
| | ------------------
------------------
1059| |
1060| | /* Graph attributes first */
1061| 3.99k| for (i = 0; i < gattr_no; i++) {
------------------
| Branch (1061:17): [True: 811, False: 3.17k]
------------------
1062| 811| const char *name;
1063| 811| char *newname;
1064| 811| name = igraph_strvector_get(&gnames, i);
1065| 811| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 656| 811| do { \
| | 657| 811| igraph_error_t igraph_i_ret = (expr); \
| | 658| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 811]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 811| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 811]
| | ------------------
------------------
1066| 811| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 811| do { \
| | 604| 811| /* the following branch makes the compiler check the compatibility of \
| | 605| 811| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 811| * incorrect destructor function with the pointer */ \
| | 607| 811| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 811]
| | ------------------
| | 608| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 811| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 811]
| | ------------------
------------------
1067| 811| if (!strcmp(newname, "directed")|| !strcmp(newname, "edge") || !strcmp(newname, "node")) {
------------------
| Branch (1067:13): [True: 4, False: 807]
| Branch (1067:44): [True: 3, False: 804]
| Branch (1067:72): [True: 8, False: 796]
------------------
1068| 15| IGRAPH_WARNINGF("The graph attribute '%s' was ignored while writing GML format.", name);
------------------
| | 777| 15| do { \
| | 778| 15| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 15| __VA_ARGS__); \
| | 780| 15| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 15]
| | ------------------
------------------
1069| 796| } else {
1070| 796| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 796|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1070:17): [True: 104, False: 692]
------------------
1071| 104| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 104| do { \
| | 657| 104| igraph_error_t igraph_i_ret = (expr); \
| | 658| 104| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 104| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 104]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 104| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 104]
| | ------------------
------------------
1072| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1073| 104| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1073:21): [True: 34, False: 70]
------------------
1074| 34| if (! isfinite(VECTOR(numv)[0])) {
------------------
| Branch (1074:25): [True: 0, False: 34]
------------------
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| 34| CHECK(fprintf(outstream, " %s ", newname));
------------------
| | 848| 34|#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: 34]
| | | Branch (848:116): [Folded, False: 34]
| | ------------------
------------------
1079| 34| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
------------------
| | 848| 34|#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: 34]
| | | Branch (848:116): [Folded, False: 34]
| | ------------------
------------------
1080| 34| CHECK(fputc('\n', outstream));
------------------
| | 848| 34|#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: 34]
| | | Branch (848:116): [Folded, False: 34]
| | ------------------
------------------
1081| 34| }
1082| 692| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 692|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1082:24): [True: 558, False: 134]
------------------
1083| 558| const char *s;
1084| 558| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 558| do { \
| | 657| 558| igraph_error_t igraph_i_ret = (expr); \
| | 658| 558| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 558| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 558]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 558| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 558]
| | ------------------
------------------
1085| 558| s = igraph_strvector_get(&strv, 0);
1086| 558| if (needs_coding(s)) {
------------------
| Branch (1086:21): [True: 70, False: 488]
------------------
1087| 70| char *d;
1088| 70| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 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]
| | ------------------
------------------
1089| 70| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 70| do { \
| | 604| 70| /* the following branch makes the compiler check the compatibility of \
| | 605| 70| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 70| * incorrect destructor function with the pointer */ \
| | 607| 70| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 70]
| | ------------------
| | 608| 70| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 70| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 70]
| | ------------------
------------------
1090| 70| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 70|#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: 70]
| | | Branch (848:116): [Folded, False: 70]
| | ------------------
------------------
1091| 70| IGRAPH_FREE(d);
------------------
| | 36| 70|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1092| 70| IGRAPH_FINALLY_CLEAN(1);
1093| 488| } else {
1094| 488| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 488|#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: 488]
| | | Branch (848:116): [Folded, False: 488]
| | ------------------
------------------
1095| 488| }
1096| 558| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 134|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1096:24): [True: 134, False: 0]
------------------
1097| 134| IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
------------------
| | 656| 134| do { \
| | 657| 134| igraph_error_t igraph_i_ret = (expr); \
| | 658| 134| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 134| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 134]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 134| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 134]
| | ------------------
------------------
1098| 134| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 268|#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: 1, False: 133]
| | | Branch (848:42): [True: 0, False: 134]
| | | Branch (848:116): [Folded, False: 134]
| | ------------------
------------------
1099| 134| IGRAPH_WARNING("A boolean graph attribute was converted to numeric.");
------------------
| | 797| 134| do { \
| | 798| 134| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 134| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 134]
| | ------------------
------------------
1100| 134| } 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| 796| }
1104| 811| IGRAPH_FREE(newname);
------------------
| | 36| 811|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1105| 811| IGRAPH_FINALLY_CLEAN(1);
1106| 811| }
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.17k|#define GETBIT(k, i) ((k) & (1 << i))
1111| 3.17k|#define SETBIT(k, i) ((k) |= (1 << i))
1112| 3.17k|#define WARN_ONCE(attrno, bit, warn) \
1113| 3.17k| do { \
1114| 3.17k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
1115| 3.17k| if (! GETBIT(*p, bit)) { \
1116| 3.17k| warn; \
1117| 3.17k| SETBIT(*p, bit); \
1118| 3.17k| } \
1119| 3.17k| } while (0)
1120| |
1121| |
1122| | /* Now come the vertices */
1123| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&warning_shown, vattr_no);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
1124| 36.1k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1124:17): [True: 32.9k, False: 3.17k]
------------------
1125| 32.9k| igraph_int_t j;
1126| 32.9k| CHECK(fprintf(outstream, " node\n [\n"));
------------------
| | 848| 32.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:42): [True: 0, False: 32.9k]
| | | Branch (848:116): [Folded, False: 32.9k]
| | ------------------
------------------
1127| | /* id */
1128| 32.9k| CHECK(fprintf(outstream, " id %" IGRAPH_PRId "\n", myid ? (igraph_int_t)VECTOR(*myid)[i] : i));
------------------
| | 848| 65.8k|#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: 32.9k]
| | | Branch (848:42): [True: 0, False: 32.9k]
| | | Branch (848:116): [Folded, False: 32.9k]
| | ------------------
------------------
1129| | /* other attributes */
1130| 84.6k| for (j = 0; j < vattr_no; j++) {
------------------
| Branch (1130:21): [True: 51.6k, False: 32.9k]
------------------
1131| 51.6k| igraph_attribute_type_t type = (igraph_attribute_type_t) VECTOR(vtypes)[j];
------------------
| | 60| 51.6k|#define VECTOR(v) ((v).stor_begin)
------------------
1132| 51.6k| const char *name;
1133| 51.6k| char *newname;
1134| 51.6k| name = igraph_strvector_get(&vnames, j);
1135| 51.6k| if (!strcmp(name, "id")) {
------------------
| Branch (1135:17): [True: 32.5k, False: 19.1k]
------------------
1136| | /* No warning, the presence of this attribute is expected, and is handled specially. */
1137| 32.5k| continue;
1138| 32.5k| }
1139| 19.1k| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 656| 19.1k| do { \
| | 657| 19.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19.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| 19.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.1k]
| | ------------------
------------------
1140| 19.1k| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 19.1k| do { \
| | 604| 19.1k| /* the following branch makes the compiler check the compatibility of \
| | 605| 19.1k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 19.1k| * incorrect destructor function with the pointer */ \
| | 607| 19.1k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 19.1k]
| | ------------------
| | 608| 19.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 19.1k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 19.1k]
| | ------------------
------------------
1141| 19.1k| if (!strcmp(newname, "id")) {
------------------
| Branch (1141:17): [True: 371, False: 18.7k]
------------------
1142| | /* In case an attribute name would conflict with 'id' only after encoding. */
1143| 371| WARN_ONCE(j, 0,
------------------
| | 1113| 371| do { \
| | 1114| 371| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 371|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 371| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 371|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 12, False: 359]
| | ------------------
| | 1116| 24| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 12]
| | ------------------
| | 1117| 12| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 12|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 12| } \
| | 1119| 371| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 371]
| | ------------------
------------------
1144| 371| IGRAPH_WARNINGF("The vertex attribute '%s' was ignored while writing GML format.", name));
1145| 18.7k| } else {
1146| 18.7k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (1146:21): [True: 2.96k, False: 15.7k]
------------------
1147| 2.96k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name,
------------------
| | 656| 2.96k| do { \
| | 657| 2.96k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.96k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.96k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.96k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.96k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.96k]
| | ------------------
------------------
1148| 2.96k| igraph_vss_1(i), &numv));
1149| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1150| 2.96k| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1150:25): [True: 2.02k, False: 936]
------------------
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.7k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (1160:28): [True: 11.6k, False: 4.13k]
------------------
1161| 11.6k| const char *s;
1162| 11.6k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name,
------------------
| | 656| 11.6k| do { \
| | 657| 11.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.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| 11.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.6k]
| | ------------------
------------------
1163| 11.6k| igraph_vss_1(i), &strv));
1164| 11.6k| s = igraph_strvector_get(&strv, 0);
1165| 11.6k| if (needs_coding(s)) {
------------------
| Branch (1165:25): [True: 5.58k, False: 6.05k]
------------------
1166| 5.58k| char *d;
1167| 5.58k| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 5.58k| do { \
| | 657| 5.58k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.58k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.58k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.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| 5.58k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.58k]
| | ------------------
------------------
1168| 5.58k| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 5.58k| do { \
| | 604| 5.58k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.58k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.58k| * incorrect destructor function with the pointer */ \
| | 607| 5.58k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.58k]
| | ------------------
| | 608| 5.58k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.58k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.58k]
| | ------------------
------------------
1169| 5.58k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 5.58k|#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.58k]
| | | Branch (848:116): [Folded, False: 5.58k]
| | ------------------
------------------
1170| 5.58k| IGRAPH_FREE(d);
------------------
| | 36| 5.58k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1171| 5.58k| IGRAPH_FINALLY_CLEAN(1);
1172| 6.05k| } else {
1173| 6.05k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 6.05k|#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.05k]
| | | Branch (848:116): [Folded, False: 6.05k]
| | ------------------
------------------
1174| 6.05k| }
1175| 11.6k| } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (1175:28): [True: 4.13k, False: 0]
------------------
1176| 4.13k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name,
------------------
| | 656| 4.13k| do { \
| | 657| 4.13k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.13k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.13k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.13k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.13k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.13k]
| | ------------------
------------------
1177| 4.13k| igraph_vss_1(i), &boolv));
1178| 4.13k| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 8.27k|#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.12k]
| | | Branch (848:42): [True: 0, False: 4.13k]
| | | Branch (848:116): [Folded, False: 4.13k]
| | ------------------
------------------
1179| 4.13k| WARN_ONCE(j, 1,
------------------
| | 1113| 4.13k| do { \
| | 1114| 4.13k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 4.13k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 4.13k| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 4.13k|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 443, False: 3.69k]
| | ------------------
| | 1116| 886| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 443]
| | ------------------
| | 1117| 443| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 443|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 443| } \
| | 1119| 4.13k| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 4.13k]
| | ------------------
------------------
1180| 4.13k| IGRAPH_WARNINGF("The boolean vertex attribute '%s' was converted to numeric.", name));
1181| 4.13k| } 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.7k| }
1186| 19.1k| IGRAPH_FREE(newname);
------------------
| | 36| 19.1k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1187| 19.1k| IGRAPH_FINALLY_CLEAN(1);
1188| 19.1k| }
1189| 32.9k| CHECK(fprintf(outstream, " ]\n"));
------------------
| | 848| 32.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:42): [True: 0, False: 32.9k]
| | | Branch (848:116): [Folded, False: 32.9k]
| | ------------------
------------------
1190| 32.9k| }
1191| |
1192| | /* The edges too */
1193| 3.17k| IGRAPH_CHECK(igraph_vector_int_resize(&warning_shown, eattr_no));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
1194| 3.17k| igraph_vector_int_null(&warning_shown);
1195| 355k| for (i = 0; i < no_of_edges; i++) {
------------------
| Branch (1195:17): [True: 352k, False: 3.17k]
------------------
1196| 352k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 352k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 352k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1197| 352k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 352k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 352k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1198| 352k| igraph_int_t j;
1199| 352k| CHECK(fprintf(outstream, " edge\n [\n"));
------------------
| | 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]
| | ------------------
------------------
1200| | /* source and target */
1201| 352k| CHECK(fprintf(outstream, " source %" IGRAPH_PRId "\n",
------------------
| | 848| 704k|#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: 352k]
| | | Branch (848:42): [True: 0, False: 352k]
| | | Branch (848:116): [Folded, False: 352k]
| | ------------------
------------------
1202| 352k| myid ? (igraph_int_t)VECTOR(*myid)[from] : from));
1203| 352k| CHECK(fprintf(outstream, " target %" IGRAPH_PRId "\n",
------------------
| | 848| 704k|#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: 352k]
| | | Branch (848:42): [True: 0, False: 352k]
| | | Branch (848:116): [Folded, False: 352k]
| | ------------------
------------------
1204| 352k| myid ? (igraph_int_t)VECTOR(*myid)[to] : to));
1205| |
1206| | /* other attributes */
1207| 800k| for (j = 0; j < eattr_no; j++) {
------------------
| Branch (1207:21): [True: 448k, False: 352k]
------------------
1208| 448k| igraph_attribute_type_t type = (igraph_attribute_type_t) VECTOR(etypes)[j];
------------------
| | 60| 448k|#define VECTOR(v) ((v).stor_begin)
------------------
1209| 448k| const char *name;
1210| 448k| char *newname;
1211| 448k| name = igraph_strvector_get(&enames, j);
1212| 448k| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 656| 448k| do { \
| | 657| 448k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 448k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 448k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 448k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 448k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 448k]
| | ------------------
------------------
1213| 448k| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 448k| do { \
| | 604| 448k| /* the following branch makes the compiler check the compatibility of \
| | 605| 448k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 448k| * incorrect destructor function with the pointer */ \
| | 607| 448k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 448k]
| | ------------------
| | 608| 448k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 448k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 448k]
| | ------------------
------------------
1214| 448k| if (!strcmp(newname, "source") || !strcmp(newname, "target")) {
------------------
| Branch (1214:17): [True: 642, False: 447k]
| Branch (1214:47): [True: 351, False: 447k]
------------------
1215| 993| WARN_ONCE(j, 0,
------------------
| | 1113| 993| do { \
| | 1114| 993| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 993|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 993| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 993|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 25, False: 968]
| | ------------------
| | 1116| 50| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 25]
| | ------------------
| | 1117| 25| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 25|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 25| } \
| | 1119| 993| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 993]
| | ------------------
------------------
1216| 993| IGRAPH_WARNINGF("The edge attribute '%s' was ignored while writing GML format.", name));
1217| 447k| } else {
1218| 447k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (1218:21): [True: 94.0k, False: 353k]
------------------
1219| 94.0k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, name,
------------------
| | 656| 94.0k| do { \
| | 657| 94.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 94.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 94.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.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| 94.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 94.0k]
| | ------------------
------------------
1220| 94.0k| igraph_ess_1(i), &numv));
1221| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1222| 94.0k| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1222:25): [True: 1.21k, False: 92.8k]
------------------
1223| 1.21k| if (! isfinite(VECTOR(numv)[0])) {
------------------
| Branch (1223:29): [True: 0, False: 1.21k]
------------------
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.21k| CHECK(fprintf(outstream, " %s ", newname));
------------------
| | 848| 1.21k|#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.21k]
| | | Branch (848:116): [Folded, False: 1.21k]
| | ------------------
------------------
1229| 1.21k| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
------------------
| | 848| 1.21k|#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.21k]
| | | Branch (848:116): [Folded, False: 1.21k]
| | ------------------
------------------
1230| 1.21k| CHECK(fputc('\n', outstream));
------------------
| | 848| 1.21k|#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.21k]
| | | Branch (848:116): [Folded, False: 1.21k]
| | ------------------
------------------
1231| 1.21k| }
1232| 353k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (1232:28): [True: 347k, False: 5.72k]
------------------
1233| 347k| const char *s;
1234| 347k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, name,
------------------
| | 656| 347k| do { \
| | 657| 347k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 347k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 347k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 347k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 347k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 347k]
| | ------------------
------------------
1235| 347k| igraph_ess_1(i), &strv));
1236| 347k| s = igraph_strvector_get(&strv, 0);
1237| 347k| if (needs_coding(s)) {
------------------
| Branch (1237:25): [True: 2.17k, False: 345k]
------------------
1238| 2.17k| char *d;
1239| 2.17k| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 2.17k| do { \
| | 657| 2.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.17k]
| | ------------------
------------------
1240| 2.17k| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 2.17k| do { \
| | 604| 2.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.17k| * incorrect destructor function with the pointer */ \
| | 607| 2.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.17k]
| | ------------------
| | 608| 2.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.17k]
| | ------------------
------------------
1241| 2.17k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 2.17k|#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.17k]
| | | Branch (848:116): [Folded, False: 2.17k]
| | ------------------
------------------
1242| 2.17k| IGRAPH_FREE(d);
------------------
| | 36| 2.17k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1243| 2.17k| IGRAPH_FINALLY_CLEAN(1);
1244| 345k| } else {
1245| 345k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 345k|#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: 345k]
| | | Branch (848:116): [Folded, False: 345k]
| | ------------------
------------------
1246| 345k| }
1247| 347k| } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (1247:28): [True: 5.72k, False: 0]
------------------
1248| 5.72k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph, name,
------------------
| | 656| 5.72k| do { \
| | 657| 5.72k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.72k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.72k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.72k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.72k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.72k]
| | ------------------
------------------
1249| 5.72k| igraph_ess_1(i), &boolv));
1250| 5.72k| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 11.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:33): [True: 0, False: 5.72k]
| | | Branch (848:42): [True: 0, False: 5.72k]
| | | Branch (848:116): [Folded, False: 5.72k]
| | ------------------
------------------
1251| 5.72k| WARN_ONCE(j, 1,
------------------
| | 1113| 5.72k| do { \
| | 1114| 5.72k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 5.72k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 5.72k| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 5.72k|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 404, False: 5.31k]
| | ------------------
| | 1116| 808| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 404]
| | ------------------
| | 1117| 404| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 404|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 404| } \
| | 1119| 5.72k| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 5.72k]
| | ------------------
------------------
1252| 5.72k| IGRAPH_WARNINGF("The boolean edge attribute '%s' was converted to numeric.", name));
1253| 5.72k| } 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| 447k| }
1258| 448k| IGRAPH_FREE(newname);
------------------
| | 36| 448k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1259| 448k| IGRAPH_FINALLY_CLEAN(1);
1260| 448k| }
1261| 352k| CHECK(fprintf(outstream, " ]\n"));
------------------
| | 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]
| | ------------------
------------------
1262| 352k| }
1263| |
1264| 3.17k| CHECK(fprintf(outstream, "]\n"));
------------------
| | 848| 3.17k|#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.17k]
| | | Branch (848:116): [Folded, False: 3.17k]
| | ------------------
------------------
1265| |
1266| 3.17k|#undef GETBIT
1267| 3.17k|#undef SETBIT
1268| 3.17k|#undef WARN_ONCE
1269| |
1270| 3.17k| if (&v_myid == myid) {
------------------
| Branch (1270:9): [True: 10, False: 3.16k]
------------------
1271| 10| igraph_vector_destroy(&v_myid);
1272| 10| IGRAPH_FINALLY_CLEAN(1);
1273| 10| }
1274| |
1275| 3.17k| igraph_vector_int_destroy(&warning_shown);
1276| 3.17k| igraph_vector_bool_destroy(&boolv);
1277| 3.17k| igraph_strvector_destroy(&strv);
1278| 3.17k| igraph_vector_destroy(&numv);
1279| 3.17k| igraph_vector_int_destroy(&etypes);
1280| 3.17k| igraph_vector_int_destroy(&vtypes);
1281| 3.17k| igraph_vector_int_destroy(>ypes);
1282| 3.17k| igraph_strvector_destroy(&enames);
1283| 3.17k| igraph_strvector_destroy(&vnames);
1284| 3.17k| igraph_strvector_destroy(&gnames);
1285| 3.17k| IGRAPH_FINALLY_CLEAN(10);
1286| |
1287| 3.17k| return IGRAPH_SUCCESS;
1288| 3.17k|}
gml.c:create_or_update_attribute:
274| 405k| igraph_attribute_record_list_t *attrs) {
275| |
276| 405k| igraph_int_t trieid, triesize = igraph_trie_size(attrnames);
277| 405k| igraph_attribute_type_t desired_type;
278| |
279| 405k| IGRAPH_CHECK(igraph_trie_get(attrnames, name, &trieid));
------------------
| | 656| 405k| do { \
| | 657| 405k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 405k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 405k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 405k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 405k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 405k]
| | ------------------
------------------
280| 405k| if (trieid == triesize) {
------------------
| Branch (280:9): [True: 6.62k, False: 399k]
------------------
281| | /* new attribute */
282| 6.62k| igraph_attribute_record_t atrec;
283| |
284| 6.62k| if (type == IGRAPH_I_GML_TREE_INTEGER || type == IGRAPH_I_GML_TREE_REAL) {
------------------
| Branch (284:13): [True: 3.61k, False: 3.00k]
| Branch (284:50): [True: 43, False: 2.96k]
------------------
285| 3.66k| desired_type = IGRAPH_ATTRIBUTE_NUMERIC;
286| 3.66k| } else if (type == IGRAPH_I_GML_TREE_STRING) {
------------------
| Branch (286:20): [True: 2.96k, False: 0]
------------------
287| 2.96k| desired_type = IGRAPH_ATTRIBUTE_STRING;
288| 2.96k| } else {
289| 0| desired_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
290| 0| }
291| |
292| 6.62k| IGRAPH_CHECK(igraph_attribute_record_init(&atrec, name, desired_type));
------------------
| | 656| 6.62k| do { \
| | 657| 6.62k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.62k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.62k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.62k]
| | ------------------
------------------
293| 6.62k| IGRAPH_FINALLY(igraph_attribute_record_destroy, &atrec);
------------------
| | 603| 6.62k| do { \
| | 604| 6.62k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.62k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.62k| * incorrect destructor function with the pointer */ \
| | 607| 6.62k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.62k]
| | ------------------
| | 608| 6.62k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.62k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.62k]
| | ------------------
------------------
294| 6.62k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(attrs, &atrec));
------------------
| | 656| 6.62k| do { \
| | 657| 6.62k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.62k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.62k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.62k]
| | ------------------
------------------
295| 6.62k| IGRAPH_FINALLY_CLEAN(1); /* ownership of 'atrec' taken by 'attrs' */
296| 399k| } else {
297| | /* already seen, should we update type? */
298| 399k| igraph_attribute_record_t *atrec = igraph_attribute_record_list_get_ptr(attrs, trieid);
299| 399k| igraph_attribute_type_t existing_type = atrec->type;
300| 399k| if (type == IGRAPH_I_GML_TREE_STRING) {
------------------
| Branch (300:13): [True: 356k, False: 42.5k]
------------------
301| 356k| if (existing_type != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (301:17): [True: 20, False: 356k]
------------------
302| 20| IGRAPH_CHECK(igraph_attribute_record_set_type(atrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 20| do { \
| | 657| 20| igraph_error_t igraph_i_ret = (expr); \
| | 658| 20| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 20| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 20]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 20| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 20]
| | ------------------
------------------
303| 20| }
304| 356k| } else if (existing_type == IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (304:20): [True: 0, False: 42.5k]
------------------
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| 399k| }
310| |
311| 405k| return IGRAPH_SUCCESS;
312| 405k|}
gml.c:strid:
262| 770k|static const char *strid(igraph_int_t id, const char *prefix) {
263| 770k| static char name[100];
264| | snprintf(name, sizeof(name) / sizeof(char) - 1, "%s%" IGRAPH_PRId, prefix, id);
------------------
| | 63| 770k|# define IGRAPH_PRId PRId64
------------------
265| 770k| return name;
266| 770k|}
gml.c:allocate_attributes:
322| 9.53k|) {
323| 9.53k| igraph_int_t i, n = igraph_attribute_record_list_size(attrs);
324| 16.1k| for (i = 0; i < n; i++) {
------------------
| Branch (324:17): [True: 6.62k, False: 9.53k]
------------------
325| 6.62k| 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.62k| if (atrec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (332:13): [True: 6.62k, False: 0]
------------------
333| 6.62k| IGRAPH_CHECK(igraph_attribute_record_resize(atrec, no_of_items));
------------------
| | 656| 6.62k| do { \
| | 657| 6.62k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.62k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.62k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.62k]
| | ------------------
------------------
334| 6.62k| } 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.62k| }
338| 9.53k| return IGRAPH_SUCCESS;
339| 9.53k|}
gml.c:igraph_i_gml_toreal:
164| 45.5k|static igraph_real_t igraph_i_gml_toreal(igraph_gml_tree_t *node, igraph_int_t pos) {
165| 45.5k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, pos);
166| |
167| 45.5k| switch (type) {
168| 45.0k| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (168:5): [True: 45.0k, False: 411]
------------------
169| 45.0k| return igraph_gml_tree_get_integer(node, pos);
170| 411| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (170:5): [True: 411, False: 45.0k]
------------------
171| 411| return igraph_gml_tree_get_real(node, pos);
172| 0| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (172:5): [True: 0, False: 45.5k]
------------------
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: 45.5k]
------------------
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| 45.5k| igraph_gml_tree_line(node, pos)); /* LCOV_EXCL_LINE */
178| 45.5k| }
179| 45.5k|}
gml.c:igraph_i_gml_tostring:
181| 360k|static const char *igraph_i_gml_tostring(igraph_gml_tree_t *node, igraph_int_t pos) {
182| 360k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, pos);
183| 360k| static char tmp[100];
184| 360k| const char *p = tmp;
185| 360k| igraph_int_t i;
186| 360k| igraph_real_t d;
187| |
188| 360k| switch (type) {
189| 211| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (189:5): [True: 211, False: 359k]
------------------
190| 211| i = igraph_gml_tree_get_integer(node, pos);
191| 211| snprintf(tmp, sizeof(tmp) / sizeof(char), "%" IGRAPH_PRId, i);
------------------
| | 63| 211|# define IGRAPH_PRId PRId64
------------------
192| 211| break;
193| 495| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (193:5): [True: 495, False: 359k]
------------------
194| 495| d = igraph_gml_tree_get_real(node, pos);
195| 495| igraph_real_snprintf_precise(tmp, sizeof(tmp) / sizeof(char), d);
196| 495| break;
197| 359k| case IGRAPH_I_GML_TREE_STRING:
------------------
| Branch (197:5): [True: 359k, False: 706]
------------------
198| 359k| p = igraph_gml_tree_get_string(node, pos);
199| 359k| break;
200| 0| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (200:5): [True: 0, False: 360k]
------------------
201| 0| tmp[0] = '\0'; /* default value of "" when composite is ignored */
202| 0| break;
203| 0| default:
------------------
| Branch (203:5): [True: 0, False: 360k]
------------------
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| 360k| igraph_gml_tree_line(node, pos)); /* LCOV_EXCL_LINE */
207| 360k| }
208| |
209| 360k| return p;
210| 360k|}
gml.c:needs_coding:
54| 722k|static igraph_bool_t needs_coding(const char *str) {
55| 39.3M| while (*str) {
------------------
| Branch (55:12): [True: 38.6M, False: 707k]
------------------
56| 38.6M| if (*str == '&' || *str == '"') {
------------------
| Branch (56:13): [True: 8.44k, False: 38.6M]
| Branch (56:28): [True: 7.21k, False: 38.6M]
------------------
57| 15.6k| return true;
58| 15.6k| }
59| 38.6M| str++;
60| 38.6M| }
61| 707k| return false;
62| 722k|}
gml.c:entity_decode:
110| 7.83k|static igraph_error_t entity_decode(const char *src, char **dest, igraph_bool_t *warned) {
111| 7.83k| const char *entity_names[] = {
112| 7.83k| """, "&", "'", "<", ">"
113| 7.83k| };
114| |
115| 7.83k| const char entity_values[] = {
116| 7.83k| '"', '&', '\'', '<', '>'
117| 7.83k| };
118| |
119| 7.83k| const int entity_count = sizeof entity_values / sizeof entity_values[0];
120| |
121| 7.83k| const char *s;
122| 7.83k| char *d;
123| 7.83k| size_t len = strlen(src);
124| 7.83k| *dest = IGRAPH_CALLOC(len+1, char); /* at most as much storage needed as for 'src' */
------------------
| | 33| 7.83k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 15.6k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 7.83k, False: 0]
| | | | | Branch (31:24): [True: 7.83k, False: 0]
| | | | | Branch (31:66): [True: 7.83k, False: 0]
| | | | ------------------
| | ------------------
------------------
125| 7.83k| IGRAPH_CHECK_OOM(dest, "Not enough memory to decode string during GML import.");
------------------
| | 709| 7.83k| do { \
| | 710| 7.83k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 7.83k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.83k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 7.83k]
| | ------------------
------------------
126| |
127| 79.3M| for (s = src, d = *dest; *s != '\0';) {
------------------
| Branch (127:30): [True: 79.2M, False: 7.83k]
------------------
128| 79.2M| if (*s == '&') {
------------------
| Branch (128:13): [True: 14.1M, False: 65.1M]
------------------
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.29k]
------------------
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| 65.1M| } else {
156| 65.1M| *d++ = *s++;
157| 65.1M| }
158| 79.2M| }
159| 7.83k| *d = '\0';
160| |
161| 7.83k| return IGRAPH_SUCCESS;
162| 7.83k|}
gml.c:prune_unknown_attributes:
236| 9.53k|static igraph_error_t prune_unknown_attributes(igraph_attribute_record_list_t *attrs) {
237| 9.53k| igraph_int_t i, n;
238| 9.53k| igraph_vector_int_t to_remove;
239| |
240| 9.53k| IGRAPH_VECTOR_INT_INIT_FINALLY(&to_remove, 0);
------------------
| | 119| 9.53k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 9.53k| do { \
| | | | 657| 9.53k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.53k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.53k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.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| 9.53k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.53k]
| | | | ------------------
| | ------------------
| | 120| 9.53k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 9.53k| do { \
| | | | 604| 9.53k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.53k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.53k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.53k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.53k]
| | | | ------------------
| | | | 608| 9.53k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.53k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.53k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 9.53k]
| | ------------------
------------------
241| |
242| 9.53k| n = igraph_attribute_record_list_size(attrs);
243| 16.1k| for (i = 0; i < n; i++) {
------------------
| Branch (243:17): [True: 6.62k, False: 9.53k]
------------------
244| 6.62k| igraph_attribute_record_t *atrec = igraph_attribute_record_list_get_ptr(attrs, i);
245| 6.62k| if (atrec->type == IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (245:13): [True: 0, False: 6.62k]
------------------
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.62k| }
249| |
250| 9.53k| n = igraph_vector_int_size(&to_remove);
251| 9.53k| for (i = n - 1; i >= 0; i--) {
------------------
| Branch (251:21): [True: 0, False: 9.53k]
------------------
252| 0| igraph_attribute_record_list_discard(attrs, VECTOR(to_remove)[i]);
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
253| 0| }
254| |
255| 9.53k| igraph_vector_int_destroy(&to_remove);
256| 9.53k| IGRAPH_FINALLY_CLEAN(1);
257| |
258| 9.53k| return IGRAPH_SUCCESS;
259| 9.53k|}
gml.c:entity_encode:
67| 7.83k|static igraph_error_t entity_encode(const char *src, char **dest, igraph_bool_t only_quot) {
68| 7.83k| igraph_int_t destlen = 0;
69| 7.83k| const char *s;
70| 7.83k| char *d;
71| |
72| 79.3M| for (s = src; *s != '\0'; s++, destlen++) {
------------------
| Branch (72:19): [True: 79.2M, False: 7.83k]
------------------
73| 79.2M| switch (*s) {
------------------
| Branch (73:17): [True: 14.1M, False: 65.1M]
------------------
74| 1.29k| case '&': /* & */
------------------
| Branch (74:9): [True: 1.29k, False: 79.2M]
------------------
75| 1.29k| if (! only_quot) {
------------------
| Branch (75:17): [True: 1.29k, False: 0]
------------------
76| 1.29k| destlen += 4;
77| 1.29k| }
78| 1.29k| break;
79| 14.1M| case '"': /* " */
------------------
| Branch (79:9): [True: 14.1M, False: 65.1M]
------------------
80| 14.1M| destlen += 5; break;
81| 79.2M| }
82| 79.2M| }
83| 7.83k| *dest = IGRAPH_CALLOC(destlen + 1, char);
------------------
| | 33| 7.83k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 15.6k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 7.83k, False: 0]
| | | | | Branch (31:24): [True: 7.83k, False: 0]
| | | | | Branch (31:66): [True: 7.83k, False: 0]
| | | | ------------------
| | ------------------
------------------
84| 7.83k| IGRAPH_CHECK_OOM(dest, "Not enough memory to encode string for GML export.");
------------------
| | 709| 7.83k| do { \
| | 710| 7.83k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 7.83k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.83k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 7.83k]
| | ------------------
------------------
85| 79.3M| for (s = src, d = *dest; *s != '\0'; s++, d++) {
------------------
| Branch (85:30): [True: 79.2M, False: 7.83k]
------------------
86| 79.2M| switch (*s) {
87| 1.29k| case '&':
------------------
| Branch (87:9): [True: 1.29k, False: 79.2M]
------------------
88| 1.29k| if (! only_quot) {
------------------
| Branch (88:17): [True: 1.29k, False: 0]
------------------
89| 1.29k| strcpy(d, "&");
90| 1.29k| d += 4;
91| 1.29k| } else {
92| 0| *d = *s;
93| 0| }
94| 1.29k| break;
95| 14.1M| case '"':
------------------
| Branch (95:9): [True: 14.1M, False: 65.1M]
------------------
96| 14.1M| strcpy(d, """); d += 5; break;
97| 65.1M| default:
------------------
| Branch (97:9): [True: 65.1M, False: 14.1M]
------------------
98| 65.1M| *d = *s;
99| 79.2M| }
100| 79.2M| }
101| 7.83k| *d = '\0';
102| 7.83k| return IGRAPH_SUCCESS;
103| 7.83k|}
gml.c:igraph_i_vector_is_duplicate_free:
821| 49|static igraph_error_t igraph_i_vector_is_duplicate_free(const igraph_vector_t *v, igraph_bool_t *res) {
822| 49| igraph_vector_t u;
823| 49| igraph_int_t n = igraph_vector_size(v);
824| |
825| 49| if (n < 2) {
------------------
| Branch (825:9): [True: 10, False: 39]
------------------
826| 10| *res = true;
827| 10| return IGRAPH_SUCCESS;
828| 10| }
829| |
830| 39| IGRAPH_CHECK(igraph_vector_init_copy(&u, v));
------------------
| | 656| 39| do { \
| | 657| 39| igraph_error_t igraph_i_ret = (expr); \
| | 658| 39| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 39| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 39]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 39]
| | ------------------
------------------
831| 39| IGRAPH_FINALLY(igraph_vector_destroy, &u);
------------------
| | 603| 39| do { \
| | 604| 39| /* the following branch makes the compiler check the compatibility of \
| | 605| 39| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 39| * incorrect destructor function with the pointer */ \
| | 607| 39| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 39]
| | ------------------
| | 608| 39| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 39| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 39]
| | ------------------
------------------
832| 39| igraph_vector_sort(&u);
833| |
834| 39| *res = true;
835| 39| for (igraph_int_t i=1; i < n; i++) {
------------------
| Branch (835:28): [True: 39, False: 0]
------------------
836| 39| if (VECTOR(u)[i-1] == VECTOR(u)[i]) {
------------------
| | 60| 39|#define VECTOR(v) ((v).stor_begin)
------------------
if (VECTOR(u)[i-1] == VECTOR(u)[i]) {
------------------
| | 60| 39|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (836:13): [True: 39, False: 0]
------------------
837| 39| *res = false;
838| 39| break;
839| 39| }
840| 39| }
841| |
842| 39| igraph_vector_destroy(&u);
843| 39| IGRAPH_FINALLY_CLEAN(1);
844| |
845| 39| return IGRAPH_SUCCESS;
846| 39|}
gml.c:igraph_i_gml_convert_to_key:
792| 468k|static igraph_error_t igraph_i_gml_convert_to_key(const char *orig, char **key) {
793| 468k| char strno[50];
794| 468k| size_t i, len = strlen(orig), newlen = 0, plen = 0;
795| |
796| | /* do we need a prefix? */
797| 468k| if (len == 0 || !isalpha(orig[0])) {
------------------
| Branch (797:9): [True: 252, False: 467k]
| Branch (797:21): [True: 7.72k, False: 460k]
------------------
798| 7.97k| snprintf(strno, sizeof(strno) - 1, "igraph");
799| 7.97k| plen = newlen = strlen(strno);
800| 7.97k| }
801| 130M| for (i = 0; i < len; i++) {
------------------
| Branch (801:17): [True: 130M, False: 468k]
------------------
802| 130M| if (isalnum(orig[i])) {
------------------
| Branch (802:13): [True: 24.9M, False: 105M]
------------------
803| 24.9M| newlen++;
804| 24.9M| }
805| 130M| }
806| 468k| *key = IGRAPH_CALLOC(newlen + 1, char);
------------------
| | 33| 468k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 936k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 468k, False: 0]
| | | | | Branch (31:24): [True: 468k, False: 0]
| | | | | Branch (31:66): [True: 468k, False: 0]
| | | | ------------------
| | ------------------
------------------
807| 468k| IGRAPH_CHECK_OOM(*key, "Writing GML format failed.");
------------------
| | 709| 468k| do { \
| | 710| 468k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 468k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 468k]
| | | | ------------------
| | ------------------
| | 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| 468k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 468k]
| | ------------------
------------------
808| 468k| memcpy(*key, strno, plen * sizeof(char));
809| 130M| for (i = 0; i < len; i++) {
------------------
| Branch (809:17): [True: 130M, False: 468k]
------------------
810| 130M| if (isalnum(orig[i])) {
------------------
| Branch (810:13): [True: 24.9M, False: 105M]
------------------
811| 24.9M| (*key)[plen++] = orig[i];
812| 24.9M| }
813| 130M| }
814| 468k| (*key)[newlen] = '\0';
815| |
816| 468k| return IGRAPH_SUCCESS;
817| 468k|}
igraph_read_graph_graphml:
1471| 22.3k|igraph_error_t igraph_read_graph_graphml(igraph_t *graph, FILE *instream, igraph_int_t index) {
1472| |
1473| 22.3k|#if HAVE_LIBXML == 1
1474| 22.3k| xmlParserCtxtPtr ctxt;
1475| 22.3k| xmlGenericErrorFunc libxml_old_generic_error_handler;
1476| 22.3k| void* libxml_old_generic_error_context;
1477| 22.3k| xmlStructuredErrorFunc libxml_old_structured_error_handler;
1478| 22.3k| void* libxml_old_structured_error_context;
1479| 22.3k| xmlDocPtr doc;
1480| |
1481| 22.3k| struct igraph_i_graphml_parser_state state;
1482| 22.3k| int res;
1483| 22.3k| char buffer[4096];
1484| 22.3k| igraph_bool_t parsing_successful;
1485| 22.3k| char* error_message;
1486| |
1487| 22.3k| if (index < 0) {
------------------
| Branch (1487:9): [True: 0, False: 22.3k]
------------------
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| 22.3k| xmlInitParser();
1492| |
1493| 22.3k| IGRAPH_CHECK(igraph_i_graphml_parser_state_init(&state, graph, index));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
1494| 22.3k| IGRAPH_FINALLY(igraph_i_graphml_parser_state_destroy, &state);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
1495| |
1496| | /* Create a progressive parser context and use the first 4K to detect the
1497| | * encoding */
1498| 22.3k| res = (int) fread(buffer, 1, sizeof(buffer), instream);
1499| 22.3k| if (res < (int) sizeof buffer && !feof(instream)) {
------------------
| Branch (1499:9): [True: 18.8k, False: 3.45k]
| Branch (1499:38): [True: 0, False: 18.8k]
------------------
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| 22.3k| libxml_old_generic_error_handler = xmlGenericError;
------------------
| | 976| 22.3k| #define xmlGenericError (*__xmlGenericError())
------------------
1506| 22.3k| libxml_old_generic_error_context = xmlGenericErrorContext;
------------------
| | 983| 22.3k| #define xmlGenericErrorContext (*__xmlGenericErrorContext())
------------------
1507| 22.3k| libxml_old_structured_error_handler = xmlStructuredError;
------------------
| | 990| 22.3k| #define xmlStructuredError (*__xmlStructuredError())
------------------
1508| 22.3k| libxml_old_structured_error_context = xmlStructuredErrorContext;
------------------
| | 997| 22.3k| #define xmlStructuredErrorContext (*__xmlStructuredErrorContext())
------------------
1509| 22.3k| xmlSetGenericErrorFunc(&state, &igraph_i_libxml_generic_error_handler);
1510| 22.3k| 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| 22.3k| IGRAPH_FINALLY_ENTER();
1518| 22.3k| {
1519| 22.3k| ctxt = xmlCreatePushParserCtxt(&igraph_i_graphml_sax_handler,
1520| 22.3k| &state,
1521| 22.3k| buffer,
1522| 22.3k| res,
1523| 22.3k| NULL);
1524| 22.3k| if (ctxt) {
------------------
| Branch (1524:13): [True: 22.3k, False: 0]
------------------
1525| 22.3k| if (xmlCtxtUseOptions(ctxt,
------------------
| Branch (1525:17): [True: 0, False: 22.3k]
------------------
1526| 22.3k| XML_PARSE_NOBLANKS |
1527| 22.3k| XML_PARSE_NONET | XML_PARSE_NSCLEAN |
1528| 22.3k| XML_PARSE_NOCDATA | XML_PARSE_HUGE
1529| 22.3k| )) {
1530| 0| xmlFreeParserCtxt(ctxt);
1531| 0| ctxt = NULL;
1532| 0| }
1533| 22.3k| }
1534| |
1535| | /* Do the parsing */
1536| 22.3k| if (ctxt) {
------------------
| Branch (1536:13): [True: 22.3k, False: 0]
------------------
1537| 372k| while ((res = (int) fread(buffer, 1, sizeof buffer, instream)) > 0) {
------------------
| Branch (1537:20): [True: 350k, False: 21.8k]
------------------
1538| 350k| xmlParseChunk(ctxt, buffer, res, 0);
1539| 350k| if (!state.successful) {
------------------
| Branch (1539:21): [True: 454, False: 350k]
------------------
1540| 454| break;
1541| 454| }
1542| 350k| IGRAPH_ALLOW_INTERRUPTION();
------------------
| | 46| 350k| do { \
| | 47| 350k| if (igraph_i_interruption_handler) { \
| | ------------------
| | | Branch (47:13): [True: 0, False: 350k]
| | ------------------
| | 48| 0| if (igraph_allow_interruption()) { \
| | ------------------
| | | Branch (48:17): [True: 0, False: 0]
| | ------------------
| | 49| 0| return IGRAPH_INTERRUPTED; \
| | 50| 0| } \
| | 51| 0| } \
| | 52| 350k| } while (0)
| | ------------------
| | | Branch (52:14): [Folded, False: 350k]
| | ------------------
------------------
1543| 350k| }
1544| 22.3k| xmlParseChunk(ctxt, buffer, res, 1);
1545| 22.3k| }
1546| 22.3k| }
1547| 22.3k| IGRAPH_FINALLY_EXIT();
1548| |
1549| | /* Restore error handlers */
1550| 22.3k| xmlSetGenericErrorFunc(libxml_old_generic_error_context, libxml_old_generic_error_handler);
1551| 22.3k| xmlSetStructuredErrorFunc(libxml_old_structured_error_context, libxml_old_structured_error_handler);
1552| |
1553| | /* Free the context */
1554| 22.3k| if (ctxt) {
------------------
| Branch (1554:9): [True: 22.3k, False: 0]
------------------
1555| 22.3k| doc = ctxt->myDoc;
1556| 22.3k| xmlFreeParserCtxt(ctxt);
1557| 22.3k| if (doc) {
------------------
| Branch (1557:13): [True: 1.35k, False: 20.9k]
------------------
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.35k| xmlFreeDoc(doc);
1561| 1.35k| }
1562| 22.3k| } 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| 22.3k| parsing_successful = state.successful;
1571| 22.3k| error_message = parsing_successful || state.error_message == NULL ? NULL : strdup(state.error_message);
------------------
| Branch (1571:21): [True: 6.35k, False: 15.9k]
| Branch (1571:43): [True: 0, False: 15.9k]
------------------
1572| |
1573| | /* ...and we can also put the error message pointer on the FINALLY stack */
1574| 22.3k| if (error_message != NULL) {
------------------
| Branch (1574:9): [True: 15.9k, False: 6.35k]
------------------
1575| 15.9k| IGRAPH_FINALLY(igraph_free, error_message);
------------------
| | 603| 15.9k| do { \
| | 604| 15.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 15.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 15.9k| * incorrect destructor function with the pointer */ \
| | 607| 15.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 15.9k]
| | ------------------
| | 608| 15.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 15.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 15.9k]
| | ------------------
------------------
1576| 15.9k| }
1577| |
1578| | /* Trigger the stored error if needed */
1579| 22.3k| if (!parsing_successful) {
------------------
| Branch (1579:9): [True: 15.9k, False: 6.35k]
------------------
1580| 15.9k| if (error_message != NULL) {
------------------
| Branch (1580:13): [True: 15.9k, False: 0]
------------------
1581| 15.9k| size_t len = strlen(error_message);
1582| 15.9k| if (error_message[len-1] == '\n') {
------------------
| Branch (1582:17): [True: 15.5k, False: 402]
------------------
1583| 15.5k| error_message[len-1] = '\0';
1584| 15.5k| }
1585| 15.9k| IGRAPH_ERROR(error_message, IGRAPH_PARSEERROR);
------------------
| | 426| 15.9k| do { \
| | 427| 15.9k| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 15.9k| return igraph_errno ; \
| | 429| 15.9k| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1586| 15.9k| } 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| 15.9k| }
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.35k| if (state.index >= 0) {
------------------
| Branch (1593:9): [True: 35, False: 6.31k]
------------------
1594| 35| IGRAPH_ERROR("Graph index was too large.", IGRAPH_EINVAL);
------------------
| | 426| 35| do { \
| | 427| 35| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 35| return igraph_errno ; \
| | 429| 35| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1595| 35| }
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.31k| IGRAPH_CHECK(igraph_i_graphml_parser_state_finish_parsing(&state));
------------------
| | 656| 6.31k| do { \
| | 657| 6.31k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.31k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.31k]
| | ------------------
------------------
1600| |
1601| 6.31k| igraph_i_graphml_parser_state_destroy(&state);
1602| 6.31k| IGRAPH_FINALLY_CLEAN(1);
1603| |
1604| 6.31k| 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.31k|}
igraph_write_graph_graphml:
1649| 3.17k| igraph_bool_t prefixattr) {
1650| 3.17k| int ret;
1651| 3.17k| igraph_int_t l, vc;
1652| 3.17k| igraph_eit_t it;
1653| 3.17k| igraph_strvector_t gnames, vnames, enames;
1654| 3.17k| igraph_vector_int_t gtypes, vtypes, etypes;
1655| 3.17k| igraph_int_t i;
1656| 3.17k| igraph_vector_t numv;
1657| 3.17k| igraph_strvector_t strv;
1658| 3.17k| igraph_vector_bool_t boolv;
1659| 3.17k| const char *gprefix = prefixattr ? "g_" : "";
------------------
| Branch (1659:27): [True: 0, False: 3.17k]
------------------
1660| 3.17k| const char *vprefix = prefixattr ? "v_" : "";
------------------
| Branch (1660:27): [True: 0, False: 3.17k]
------------------
1661| 3.17k| const char *eprefix = prefixattr ? "e_" : "";
------------------
| Branch (1661:27): [True: 0, False: 3.17k]
------------------
1662| 3.17k| char what[100];
1663| |
1664| 3.17k| ret = fprintf(outstream, "\n");
1665| 3.17k| if (ret < 0) {
------------------
| Branch (1665:9): [True: 0, False: 3.17k]
------------------
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.17k| ret = fprintf(outstream, "\n", GRAPHML_NAMESPACE_URI);
------------------
| | 38| 3.17k|#define GRAPHML_NAMESPACE_URI "http://graphml.graphdrawing.org/xmlns"
------------------
1681| 3.17k| if (ret < 0) {
------------------
| Branch (1681:9): [True: 0, False: 3.17k]
------------------
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.17k| ret = fprintf(outstream, "\n");
1685| 3.17k| if (ret < 0) {
------------------
| Branch (1685:9): [True: 0, False: 3.17k]
------------------
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.17k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.17k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 105| 3.17k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.17k]
| | ------------------
------------------
1692| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
1693| 3.17k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);
------------------
| | 109| 3.17k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 110| 3.17k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.17k]
| | ------------------
------------------
1694| |
1695| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
1696| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
1697| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
1698| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
1699| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
1700| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
1701| 3.17k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
1702| 3.17k| &gnames, >ypes,
1703| 3.17k| &vnames, &vtypes,
1704| 3.17k| &enames, &etypes));
1705| |
1706| | /* graph attributes */
1707| 3.99k| for (i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (1707:17): [True: 811, False: 3.17k]
------------------
1708| 811| const char *name; char *name_escaped;
1709| 811| name = igraph_strvector_get(&gnames, i);
1710| 811| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 811| do { \
| | 657| 811| igraph_error_t igraph_i_ret = (expr); \
| | 658| 811| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 811| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 811]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 811| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 811]
| | ------------------
------------------
1711| 811| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 603| 811| do { \
| | 604| 811| /* the following branch makes the compiler check the compatibility of \
| | 605| 811| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 811| * incorrect destructor function with the pointer */ \
| | 607| 811| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 811]
| | ------------------
| | 608| 811| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 811| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 811]
| | ------------------
------------------
1712| 811| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 811|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1712:13): [True: 563, False: 248]
------------------
1713| 563| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1714| 563| if (ret < 0) {
------------------
| Branch (1714:17): [True: 0, False: 563]
------------------
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| 563| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 248|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1717:20): [True: 111, False: 137]
------------------
1718| 111| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1719| 111| if (ret < 0) {
------------------
| Branch (1719:17): [True: 0, False: 111]
------------------
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| 137| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 137|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1722:20): [True: 137, False: 0]
------------------
1723| 137| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1724| 137| if (ret < 0) {
------------------
| Branch (1724:17): [True: 0, False: 137]
------------------
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| 137| }
1728| 811| IGRAPH_FREE(name_escaped);
------------------
| | 36| 811|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1729| 811| IGRAPH_FINALLY_CLEAN(1);
1730| 811| }
1731| |
1732| | /* vertex attributes */
1733| 8.08k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1733:17): [True: 4.90k, False: 3.17k]
------------------
1734| 4.90k| const char *name; char *name_escaped;
1735| 4.90k| name = igraph_strvector_get(&vnames, i);
1736| 4.90k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 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]
| | ------------------
------------------
1737| 4.90k| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 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]
| | ------------------
------------------
1738| 4.90k| if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 4.90k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1738:13): [True: 4.10k, False: 794]
------------------
1739| 4.10k| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1740| 4.10k| if (ret < 0) {
------------------
| Branch (1740:17): [True: 0, False: 4.10k]
------------------
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.10k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 794|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1743:20): [True: 290, False: 504]
------------------
1744| 290| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1745| 290| if (ret < 0) {
------------------
| Branch (1745:17): [True: 0, False: 290]
------------------
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| 504| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 504|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1748:20): [True: 504, False: 0]
------------------
1749| 504| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1750| 504| if (ret < 0) {
------------------
| Branch (1750:17): [True: 0, False: 504]
------------------
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| 504| }
1754| 4.90k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 4.90k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1755| 4.90k| IGRAPH_FINALLY_CLEAN(1);
1756| 4.90k| }
1757| |
1758| | /* edge attributes */
1759| 5.86k| for (i = 0; i < igraph_vector_int_size(&etypes); i++) {
------------------
| Branch (1759:17): [True: 2.68k, False: 3.17k]
------------------
1760| 2.68k| const char *name; char *name_escaped;
1761| 2.68k| name = igraph_strvector_get(&enames, i);
1762| 2.68k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 2.68k| do { \
| | 657| 2.68k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.68k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.68k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.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| 2.68k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.68k]
| | ------------------
------------------
1763| 2.68k| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 603| 2.68k| do { \
| | 604| 2.68k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.68k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.68k| * incorrect destructor function with the pointer */ \
| | 607| 2.68k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.68k]
| | ------------------
| | 608| 2.68k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.68k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.68k]
| | ------------------
------------------
1764| 2.68k| if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 2.68k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1764:13): [True: 1.80k, False: 880]
------------------
1765| 1.80k| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1766| 1.80k| if (ret < 0) {
------------------
| Branch (1766:17): [True: 0, False: 1.80k]
------------------
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.80k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 880|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1769:20): [True: 425, False: 455]
------------------
1770| 425| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1771| 425| if (ret < 0) {
------------------
| Branch (1771:17): [True: 0, False: 425]
------------------
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| 455| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 455|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1774:20): [True: 455, False: 0]
------------------
1775| 455| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1776| 455| if (ret < 0) {
------------------
| Branch (1776:17): [True: 0, False: 455]
------------------
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| 455| }
1780| 2.68k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 2.68k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1781| 2.68k| IGRAPH_FINALLY_CLEAN(1);
1782| 2.68k| }
1783| |
1784| 3.17k| ret = fprintf(outstream, " \n", (igraph_is_directed(graph) ? "directed" : "undirected"));
------------------
| Branch (1784:74): [True: 133, False: 3.04k]
------------------
1785| 3.17k| if (ret < 0) {
------------------
| Branch (1785:9): [True: 0, False: 3.17k]
------------------
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| 3.99k| for (i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (1791:17): [True: 811, False: 3.17k]
------------------
1792| 811| const char *name; char *name_escaped;
1793| 811| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 811|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1793:13): [True: 111, False: 700]
------------------
1794| 111| name = igraph_strvector_get(&gnames, i);
1795| 111| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 111| do { \
| | 657| 111| igraph_error_t igraph_i_ret = (expr); \
| | 658| 111| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 111| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 111]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 111| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 111]
| | ------------------
------------------
1796| 111| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1796:17): [True: 34, False: 77]
------------------
1797| 34| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 34| do { \
| | 657| 34| igraph_error_t igraph_i_ret = (expr); \
| | 658| 34| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 34| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 34]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 34| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 34]
| | ------------------
------------------
1798| 34| ret = fprintf(outstream, " ", gprefix, name_escaped);
1799| 34| IGRAPH_FREE(name_escaped);
------------------
| | 36| 34|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1800| 34| if (ret < 0) {
------------------
| Branch (1800:21): [True: 0, False: 34]
------------------
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| 34| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 34|#define VECTOR(v) ((v).stor_begin)
------------------
1804| 34| if (ret < 0) {
------------------
| Branch (1804:21): [True: 0, False: 34]
------------------
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| 34| ret = fprintf(outstream, "\n");
1808| 34| if (ret < 0) {
------------------
| Branch (1808:21): [True: 0, False: 34]
------------------
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| 34| }
1812| 700| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 700|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1812:20): [True: 563, False: 137]
------------------
1813| 563| const char *s;
1814| 563| char *s_escaped;
1815| 563| name = igraph_strvector_get(&gnames, i);
1816| 563| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 563| do { \
| | 657| 563| igraph_error_t igraph_i_ret = (expr); \
| | 658| 563| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 563| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 563]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 563| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 563]
| | ------------------
------------------
1817| 563| ret = fprintf(outstream, " ", gprefix,
1818| 563| name_escaped);
1819| 563| IGRAPH_FREE(name_escaped);
------------------
| | 36| 563|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1820| 563| if (ret < 0) {
------------------
| Branch (1820:17): [True: 0, False: 563]
------------------
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| 563| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 563| do { \
| | 657| 563| igraph_error_t igraph_i_ret = (expr); \
| | 658| 563| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 563| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 563]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 563| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 563]
| | ------------------
------------------
1824| 563| s = igraph_strvector_get(&strv, 0);
1825| 563| snprintf(what, sizeof(what) / sizeof(what[0]), "the value of the '%s' graph attribute", name);
1826| 563| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 563| do { \
| | 657| 563| igraph_error_t igraph_i_ret = (expr); \
| | 658| 563| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 563| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 563]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 563| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 563]
| | ------------------
------------------
1827| 563| ret = fprintf(outstream, "%s", s_escaped);
1828| 563| IGRAPH_FREE(s_escaped);
------------------
| | 36| 563|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1829| 563| if (ret < 0) {
------------------
| Branch (1829:17): [True: 0, False: 563]
------------------
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| 563| ret = fprintf(outstream, "\n");
1833| 563| if (ret < 0) {
------------------
| Branch (1833:17): [True: 0, False: 563]
------------------
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| 563| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 137|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1836:20): [True: 137, False: 0]
------------------
1837| 137| name = igraph_strvector_get(&gnames, i);
1838| 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]
| | ------------------
------------------
1839| 137| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 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]
| | ------------------
------------------
1840| 137| ret = fprintf(outstream, " %s\n",
1841| 137| gprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 137|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1841:50): [True: 1, False: 136]
------------------
1842| 137| IGRAPH_FREE(name_escaped);
------------------
| | 36| 137|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1843| 137| if (ret < 0) {
------------------
| Branch (1843:17): [True: 0, False: 137]
------------------
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| 137| }
1847| 811| }
1848| |
1849| | /* Let's dump the nodes first */
1850| 3.17k| vc = igraph_vcount(graph);
1851| 36.1k| for (l = 0; l < vc; l++) {
------------------
| Branch (1851:17): [True: 32.9k, False: 3.17k]
------------------
1852| 32.9k| const char *name; char *name_escaped;
1853| 32.9k| ret = fprintf(outstream, " \n", l);
1854| |
1855| 32.9k| if (ret < 0) {
------------------
| Branch (1855:13): [True: 0, False: 32.9k]
------------------
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| 84.6k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1859:21): [True: 51.6k, False: 32.9k]
------------------
1860| 51.6k| if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 51.6k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1860:17): [True: 5.42k, False: 46.2k]
------------------
1861| 5.42k| name = igraph_strvector_get(&vnames, i);
1862| 5.42k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name,
------------------
| | 656| 5.42k| do { \
| | 657| 5.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.42k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.42k]
| | ------------------
------------------
1863| 5.42k| igraph_vss_1(l), &numv));
1864| 5.42k| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1864:21): [True: 4.47k, False: 952]
------------------
1865| 4.47k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 4.47k| do { \
| | 657| 4.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.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| 4.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.47k]
| | ------------------
------------------
1866| 4.47k| ret = fprintf(outstream, " ", vprefix, name_escaped);
1867| 4.47k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 4.47k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1868| 4.47k| if (ret < 0) {
------------------
| Branch (1868:25): [True: 0, False: 4.47k]
------------------
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.47k| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 4.47k|#define VECTOR(v) ((v).stor_begin)
------------------
1872| 4.47k| if (ret < 0) {
------------------
| Branch (1872:25): [True: 0, False: 4.47k]
------------------
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.47k| ret = fprintf(outstream, "\n");
1876| 4.47k| if (ret < 0) {
------------------
| Branch (1876:25): [True: 0, False: 4.47k]
------------------
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.47k| }
1880| 46.2k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 46.2k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1880:24): [True: 42.1k, False: 4.13k]
------------------
1881| 42.1k| const char *s;
1882| 42.1k| char *s_escaped;
1883| 42.1k| name = igraph_strvector_get(&vnames, i);
1884| 42.1k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 42.1k| do { \
| | 657| 42.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.1k]
| | ------------------
------------------
1885| 42.1k| ret = fprintf(outstream, " ", vprefix,
1886| 42.1k| name_escaped);
1887| 42.1k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 42.1k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1888| 42.1k| if (ret < 0) {
------------------
| Branch (1888:21): [True: 0, False: 42.1k]
------------------
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.1k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name,
------------------
| | 656| 42.1k| do { \
| | 657| 42.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.1k]
| | ------------------
------------------
1892| 42.1k| igraph_vss_1(l), &strv));
1893| 42.1k| s = igraph_strvector_get(&strv, 0);
1894| 42.1k| snprintf(what, sizeof(what) / sizeof(what[0]), "a value of the '%s' vertex attribute", name);
1895| 42.1k| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 42.1k| do { \
| | 657| 42.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.1k]
| | ------------------
------------------
1896| 42.1k| ret = fprintf(outstream, "%s", s_escaped);
1897| 42.1k| IGRAPH_FREE(s_escaped);
------------------
| | 36| 42.1k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1898| 42.1k| if (ret < 0) {
------------------
| Branch (1898:21): [True: 0, False: 42.1k]
------------------
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.1k| ret = fprintf(outstream, "\n");
1902| 42.1k| if (ret < 0) {
------------------
| Branch (1902:21): [True: 0, False: 42.1k]
------------------
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.1k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 4.13k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1905:24): [True: 4.13k, False: 0]
------------------
1906| 4.13k| name = igraph_strvector_get(&vnames, i);
1907| 4.13k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name,
------------------
| | 656| 4.13k| do { \
| | 657| 4.13k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.13k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.13k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.13k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.13k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.13k]
| | ------------------
------------------
1908| 4.13k| igraph_vss_1(l), &boolv));
1909| 4.13k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 4.13k| do { \
| | 657| 4.13k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.13k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.13k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.13k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.13k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.13k]
| | ------------------
------------------
1910| 4.13k| ret = fprintf(outstream, " %s\n",
1911| 4.13k| vprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 4.13k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1911:54): [True: 16, False: 4.12k]
------------------
1912| 4.13k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 4.13k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1913| 4.13k| if (ret < 0) {
------------------
| Branch (1913:21): [True: 0, False: 4.13k]
------------------
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.13k| }
1917| 51.6k| }
1918| |
1919| 32.9k| ret = fprintf(outstream, " \n");
1920| 32.9k| if (ret < 0) {
------------------
| Branch (1920:13): [True: 0, False: 32.9k]
------------------
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| 32.9k| }
1924| |
1925| | /* Now the edges */
1926| 3.17k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &it));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
1927| 3.17k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
1928| 355k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 355k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (1928:12): [True: 352k, False: 3.17k]
------------------
1929| 352k| igraph_int_t from, to;
1930| 352k| const char *name; char *name_escaped;
1931| 352k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 352k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 352k, False: 0]
| | ------------------
| | 406| 352k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1932| |
1933| 352k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 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]
| | ------------------
------------------
1934| 352k| ret = fprintf(outstream, " \n",
1935| 352k| from, to);
1936| 352k| if (ret < 0) {
------------------
| Branch (1936:13): [True: 0, False: 352k]
------------------
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| 800k| for (i = 0; i < igraph_vector_int_size(&etypes); i++) {
------------------
| Branch (1940:21): [True: 448k, False: 352k]
------------------
1941| 448k| if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 448k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1941:17): [True: 94.6k, False: 353k]
------------------
1942| 94.6k| name = igraph_strvector_get(&enames, i);
1943| 94.6k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, name,
------------------
| | 656| 94.6k| do { \
| | 657| 94.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 94.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 94.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 94.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| 94.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 94.6k]
| | ------------------
------------------
1944| 94.6k| igraph_ess_1(edge), &numv));
1945| 94.6k| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1945:21): [True: 1.21k, False: 93.4k]
------------------
1946| 1.21k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 1.21k| do { \
| | 657| 1.21k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.21k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.21k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.21k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.21k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.21k]
| | ------------------
------------------
1947| 1.21k| ret = fprintf(outstream, " ", eprefix, name_escaped);
1948| 1.21k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 1.21k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1949| 1.21k| if (ret < 0) {
------------------
| Branch (1949:25): [True: 0, False: 1.21k]
------------------
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.21k| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 1.21k|#define VECTOR(v) ((v).stor_begin)
------------------
1953| 1.21k| if (ret < 0) {
------------------
| Branch (1953:25): [True: 0, False: 1.21k]
------------------
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.21k| ret = fprintf(outstream, "\n");
1957| 1.21k| if (ret < 0) {
------------------
| Branch (1957:25): [True: 0, False: 1.21k]
------------------
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.21k| }
1961| 353k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 353k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1961:24): [True: 347k, False: 5.88k]
------------------
1962| 347k| const char *s;
1963| 347k| char *s_escaped;
1964| 347k| name = igraph_strvector_get(&enames, i);
1965| 347k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 347k| do { \
| | 657| 347k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 347k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 347k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 347k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 347k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 347k]
| | ------------------
------------------
1966| 347k| ret = fprintf(outstream, " ", eprefix,
1967| 347k| name_escaped);
1968| 347k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 347k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1969| 347k| if (ret < 0) {
------------------
| Branch (1969:21): [True: 0, False: 347k]
------------------
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| 347k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, name,
------------------
| | 656| 347k| do { \
| | 657| 347k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 347k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 347k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 347k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 347k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 347k]
| | ------------------
------------------
1973| 347k| igraph_ess_1(edge), &strv));
1974| 347k| s = igraph_strvector_get(&strv, 0);
1975| 347k| snprintf(what, sizeof(what) / sizeof(what[0]), "a value of the '%s' edge attribute", name);
1976| 347k| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 347k| do { \
| | 657| 347k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 347k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 347k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 347k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 347k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 347k]
| | ------------------
------------------
1977| 347k| ret = fprintf(outstream, "%s", s_escaped);
1978| 347k| IGRAPH_FREE(s_escaped);
------------------
| | 36| 347k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1979| 347k| if (ret < 0) {
------------------
| Branch (1979:21): [True: 0, False: 347k]
------------------
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| 347k| ret = fprintf(outstream, "\n");
1983| 347k| if (ret < 0) {
------------------
| Branch (1983:21): [True: 0, False: 347k]
------------------
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| 347k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 5.88k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1986:24): [True: 5.88k, False: 0]
------------------
1987| 5.88k| name = igraph_strvector_get(&enames, i);
1988| 5.88k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph, name,
------------------
| | 656| 5.88k| do { \
| | 657| 5.88k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.88k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.88k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.88k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.88k]
| | ------------------
------------------
1989| 5.88k| igraph_ess_1(edge), &boolv));
1990| 5.88k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 5.88k| do { \
| | 657| 5.88k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.88k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.88k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.88k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.88k]
| | ------------------
------------------
1991| 5.88k| ret = fprintf(outstream, " %s\n",
1992| 5.88k| eprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 5.88k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1992:54): [True: 0, False: 5.88k]
------------------
1993| 5.88k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 5.88k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1994| 5.88k| if (ret < 0) {
------------------
| Branch (1994:21): [True: 0, False: 5.88k]
------------------
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| 5.88k| }
1998| 448k| }
1999| |
2000| 352k| ret = fprintf(outstream, " \n");
2001| 352k| if (ret < 0) {
------------------
| Branch (2001:13): [True: 0, False: 352k]
------------------
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| 352k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 352k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
2005| 352k| }
2006| 3.17k| igraph_eit_destroy(&it);
2007| 3.17k| IGRAPH_FINALLY_CLEAN(1);
2008| |
2009| 3.17k| ret = fprintf(outstream, " \n");
2010| 3.17k| if (ret < 0) {
------------------
| Branch (2010:9): [True: 0, False: 3.17k]
------------------
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.17k| fprintf(outstream, "\n");
2014| 3.17k| if (ret < 0) {
------------------
| Branch (2014:9): [True: 0, False: 3.17k]
------------------
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.17k| igraph_strvector_destroy(&gnames);
2019| 3.17k| igraph_strvector_destroy(&vnames);
2020| 3.17k| igraph_strvector_destroy(&enames);
2021| 3.17k| igraph_vector_int_destroy(>ypes);
2022| 3.17k| igraph_vector_int_destroy(&vtypes);
2023| 3.17k| igraph_vector_int_destroy(&etypes);
2024| 3.17k| igraph_vector_destroy(&numv);
2025| 3.17k| igraph_strvector_destroy(&strv);
2026| 3.17k| igraph_vector_bool_destroy(&boolv);
2027| 3.17k| IGRAPH_FINALLY_CLEAN(9);
2028| |
2029| 3.17k| return IGRAPH_SUCCESS;
2030| 3.17k|}
graphml.c:igraph_i_graphml_parser_state_init:
221| 22.3k|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| 22.3k| memset(state, 0, sizeof(struct igraph_i_graphml_parser_state));
223| |
224| 22.3k| state->g = graph;
225| 22.3k| state->index = index < 0 ? 0 : index;
------------------
| Branch (225:20): [True: 0, False: 22.3k]
------------------
226| 22.3k| state->successful = 1;
227| 22.3k| state->error_message = NULL;
228| |
229| 22.3k| IGRAPH_CHECK(igraph_vector_int_init(&state->prev_state_stack, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
230| 22.3k| IGRAPH_CHECK(igraph_vector_int_reserve(&state->prev_state_stack, 32));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
231| 22.3k| IGRAPH_FINALLY(igraph_vector_int_destroy, &state->prev_state_stack);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
232| |
233| 22.3k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->v_attrs, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
234| 22.3k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->v_attrs,
------------------
| | 94| 22.3k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
235| 22.3k| igraph_i_graphml_attribute_record_destroy);
236| 22.3k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->v_attrs);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
237| |
238| 22.3k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->e_attrs, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
239| 22.3k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->e_attrs,
------------------
| | 94| 22.3k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
240| 22.3k| igraph_i_graphml_attribute_record_destroy);
241| 22.3k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->e_attrs);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
242| |
243| 22.3k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->g_attrs, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
244| 22.3k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->g_attrs,
------------------
| | 94| 22.3k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
245| 22.3k| igraph_i_graphml_attribute_record_destroy);
246| 22.3k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->g_attrs);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
247| |
248| 22.3k| IGRAPH_CHECK(igraph_vector_int_init(&state->edgelist, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
249| 22.3k| IGRAPH_FINALLY(igraph_vector_int_destroy, &state->edgelist);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
250| |
251| 22.3k| IGRAPH_CHECK(igraph_trie_init(&state->node_trie, 1));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
252| 22.3k| IGRAPH_FINALLY(igraph_trie_destroy, &state->node_trie);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
253| |
254| 22.3k| IGRAPH_CHECK(igraph_strvector_init(&state->edgeids, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
255| 22.3k| IGRAPH_FINALLY(igraph_strvector_destroy, &state->edgeids);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
256| |
257| 22.3k| IGRAPH_CHECK(igraph_trie_init(&state->v_attr_ids, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
258| 22.3k| IGRAPH_FINALLY(igraph_trie_destroy, &state->v_attr_ids);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
259| |
260| 22.3k| IGRAPH_CHECK(igraph_trie_init(&state->e_attr_ids, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
261| 22.3k| IGRAPH_FINALLY(igraph_trie_destroy, &state->e_attr_ids);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
262| |
263| 22.3k| IGRAPH_CHECK(igraph_trie_init(&state->g_attr_ids, 0));
------------------
| | 656| 22.3k| do { \
| | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22.3k]
| | ------------------
------------------
264| 22.3k| IGRAPH_FINALLY(igraph_trie_destroy, &state->g_attr_ids);
------------------
| | 603| 22.3k| do { \
| | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | 607| 22.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 22.3k]
| | ------------------
| | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 22.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 22.3k]
| | ------------------
------------------
265| |
266| 22.3k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&state->data_char, 0);
------------------
| | 114| 22.3k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 22.3k| do { \
| | | | 657| 22.3k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 22.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 22.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 22.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| 22.3k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 22.3k]
| | | | ------------------
| | ------------------
| | 115| 22.3k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 22.3k| do { \
| | | | 604| 22.3k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 22.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 22.3k| * incorrect destructor function with the pointer */ \
| | | | 607| 22.3k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 22.3k]
| | | | ------------------
| | | | 608| 22.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 22.3k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 22.3k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 22.3k]
| | ------------------
------------------
267| |
268| 22.3k| IGRAPH_FINALLY_CLEAN(11);
269| |
270| 22.3k| return IGRAPH_SUCCESS;
271| 22.3k|}
graphml.c:igraph_i_graphml_attribute_record_destroy:
208| 16.9k|static void igraph_i_graphml_attribute_record_destroy(igraph_i_graphml_attribute_record_t* rec) {
209| 16.9k| if (!rec->record_disowned) {
------------------
| Branch (209:9): [True: 4.24k, False: 12.6k]
------------------
210| 4.24k| igraph_attribute_record_destroy(&rec->record);
211| 4.24k| }
212| |
213| 16.9k| if (rec->id != NULL) {
------------------
| Branch (213:9): [True: 16.7k, False: 213]
------------------
214| 16.7k| igraph_free(rec->id);
215| 16.7k| rec->id = NULL;
216| 16.7k| }
217| |
218| 16.9k| memset(rec, 0, sizeof(igraph_i_graphml_attribute_record_t));
219| 16.9k|}
graphml.c:igraph_i_graphml_parser_state_destroy:
273| 22.3k|static void igraph_i_graphml_parser_state_destroy(struct igraph_i_graphml_parser_state* state) {
274| 22.3k| igraph_trie_destroy(&state->node_trie);
275| 22.3k| igraph_strvector_destroy(&state->edgeids);
276| 22.3k| igraph_trie_destroy(&state->v_attr_ids);
277| 22.3k| igraph_trie_destroy(&state->e_attr_ids);
278| 22.3k| igraph_trie_destroy(&state->g_attr_ids);
279| 22.3k| igraph_vector_int_destroy(&state->edgelist);
280| 22.3k| igraph_vector_int_destroy(&state->prev_state_stack);
281| |
282| 22.3k| igraph_vector_ptr_destroy_all(&state->v_attrs);
283| 22.3k| igraph_vector_ptr_destroy_all(&state->e_attrs);
284| 22.3k| igraph_vector_ptr_destroy_all(&state->g_attrs);
285| |
286| 22.3k| igraph_vector_char_destroy(&state->data_char);
287| |
288| 22.3k| if (state->data_key) {
------------------
| Branch (288:9): [True: 3.41k, False: 18.8k]
------------------
289| 3.41k| xmlFree((void *) state->data_key);
290| 3.41k| state->data_key = NULL;
291| 3.41k| }
292| |
293| 22.3k| if (state->error_message) {
------------------
| Branch (293:9): [True: 16.0k, False: 6.28k]
------------------
294| | IGRAPH_FREE(state->error_message);
------------------
| | 36| 16.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
295| 16.0k| }
296| 22.3k|}
graphml.c:igraph_i_graphml_parser_state_set_error_from_varargs:
300| 545|) {
301| 545| const size_t max_error_message_length = 4096;
302| |
303| 545| state->successful = 0;
304| 545| state->st = ERROR;
305| |
306| 545| if (state->error_message == 0) {
------------------
| Branch (306:9): [True: 530, False: 15]
------------------
307| | /* ownership of state->error_message passed on immediately to
308| | * state so the state destructor is responsible for freeing it */
309| 530| state->error_message = IGRAPH_CALLOC(max_error_message_length, char);
------------------
| | 33| 530|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.06k| (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: 530, Folded]
| | | | ------------------
| | ------------------
------------------
310| 530| }
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| 545| if (state->error_message != 0) {
------------------
| Branch (314:9): [True: 545, False: 0]
------------------
315| 545| vsnprintf(state->error_message, max_error_message_length, msg, args);
316| 545| }
317| 545|}
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: 15.4k, False: 221k]
------------------
328| | /* ownership of state->error_message passed on immediately to
329| | * state so the state destructor is responsible for freeing it */
330| 15.4k| state->error_message = IGRAPH_CALLOC(max_error_message_length, char);
------------------
| | 33| 15.4k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 30.9k| (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: 15.4k, Folded]
| | | | ------------------
| | ------------------
------------------
331| 15.4k| }
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.4k| const xmlChar* name) {
352| 19.4k| xmlEntityPtr predef = xmlGetPredefinedEntity(name);
353| 19.4k| const char* entityName;
354| |
355| 19.4k| IGRAPH_UNUSED(state0);
------------------
| | 30| 19.4k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
356| 19.4k| if (predef != NULL) {
------------------
| Branch (356:9): [True: 5.12k, False: 14.3k]
------------------
357| 5.12k| return predef;
358| 5.12k| }
359| |
360| 14.3k| entityName = fromXmlChar(name);
------------------
| | 76| 14.3k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
361| 14.3k| IGRAPH_WARNINGF("Unknown XML entity found: '%s'.", entityName);
------------------
| | 777| 14.3k| do { \
| | 778| 14.3k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 14.3k| __VA_ARGS__); \
| | 780| 14.3k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 14.3k]
| | ------------------
------------------
362| |
363| 14.3k| return &blankEntity;
364| 19.4k|}
graphml.c:igraph_i_graphml_sax_handler_start_document:
377| 21.5k|static void igraph_i_graphml_sax_handler_start_document(void *state0) {
378| 21.5k| struct igraph_i_graphml_parser_state *state =
379| 21.5k| (struct igraph_i_graphml_parser_state*)state0;
380| |
381| 21.5k| state->st = START;
382| 21.5k| state->successful = 1;
383| 21.5k| state->edges_directed = 0;
384| | state->data_key = NULL;
385| 21.5k| state->unknown_depth = 0;
386| 21.5k| state->ignore_namespaces = 0;
387| 21.5k|}
graphml.c:igraph_i_graphml_sax_handler_chars:
1298| 42.6M|static void igraph_i_graphml_sax_handler_chars(void* state0, const xmlChar* ch, int len) {
1299| 42.6M| struct igraph_i_graphml_parser_state *state =
1300| 42.6M| (struct igraph_i_graphml_parser_state*)state0;
1301| 42.6M| igraph_error_t result = IGRAPH_SUCCESS;
1302| |
1303| 42.6M| if (!state->successful) {
------------------
| Branch (1303:9): [True: 9.69k, False: 42.6M]
------------------
1304| 9.69k| return;
1305| 9.69k| }
1306| |
1307| 42.6M| switch (state->st) {
1308| 2.59k| case INSIDE_KEY:
------------------
| Branch (1308:5): [True: 2.59k, False: 42.6M]
------------------
1309| 2.59k| break;
1310| |
1311| 40.8M| case INSIDE_DATA:
------------------
| Branch (1311:5): [True: 40.8M, False: 1.80M]
------------------
1312| 40.8M| case INSIDE_DEFAULT:
------------------
| Branch (1312:5): [True: 12.0k, False: 42.6M]
------------------
1313| 40.8M| result = igraph_i_graphml_append_to_data_char(state, ch, len);
1314| 40.8M| break;
1315| |
1316| 1.78M| default:
------------------
| Branch (1316:5): [True: 1.78M, False: 40.8M]
------------------
1317| | /* just ignore it */
1318| 1.78M| break;
1319| 42.6M| }
1320| |
1321| 42.6M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1321:9): [True: 0, False: 42.6M]
------------------
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| 42.6M|}
graphml.c:igraph_i_graphml_append_to_data_char:
780| 40.8M|) {
781| 40.8M| const igraph_vector_char_t data_vec =
782| 40.8M| igraph_vector_char_view((char *) data, len);
783| |
784| 40.8M| if (!state->successful) {
------------------
| Branch (784:9): [True: 0, False: 40.8M]
------------------
785| 0| return IGRAPH_SUCCESS;
786| 0| }
787| |
788| 40.8M| IGRAPH_STATIC_ASSERT(sizeof(char) == sizeof(xmlChar));
------------------
| | 68| 40.8M|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
789| 40.8M| IGRAPH_CHECK(igraph_vector_char_append(
------------------
| | 656| 40.8M| do { \
| | 657| 40.8M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 40.8M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 40.8M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 40.8M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 40.8M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 40.8M]
| | ------------------
------------------
790| 40.8M| &state->data_char,
791| 40.8M| &data_vec
792| 40.8M| ));
793| |
794| 40.8M| return IGRAPH_SUCCESS;
795| 40.8M|}
graphml.c:igraph_i_graphml_sax_handler_error:
341| 545|static void igraph_i_graphml_sax_handler_error(void *state0, const char* msg, ...) {
342| 545| struct igraph_i_graphml_parser_state *state =
343| 545| (struct igraph_i_graphml_parser_state*)state0;
344| 545| va_list args;
345| 545| va_start(args, msg);
346| 545| igraph_i_graphml_parser_state_set_error_from_varargs(state, msg, args);
347| | va_end(args);
348| 545|}
graphml.c:igraph_i_graphml_sax_handler_start_element_ns:
1198| 4.06M| int nb_attributes, int nb_defaulted, const xmlChar** attributes) {
1199| 4.06M| struct igraph_i_graphml_parser_state *state =
1200| 4.06M| (struct igraph_i_graphml_parser_state*)state0;
1201| 4.06M| igraph_error_t result;
1202| |
1203| 4.06M| if (!state->successful) {
------------------
| Branch (1203:9): [True: 55.5k, False: 4.01M]
------------------
1204| 55.5k| return;
1205| 55.5k| }
1206| |
1207| 4.01M| result = igraph_i_graphml_sax_handler_start_element_ns_inner(
1208| 4.01M| state, localname, prefix, uri, nb_namespaces, namespaces,
1209| 4.01M| nb_attributes, nb_defaulted, attributes
1210| 4.01M| );
1211| |
1212| 4.01M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1212:9): [True: 452, False: 4.01M]
------------------
1213| 452| RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file.", result);
------------------
| | 85| 452| do { \
| | 86| 452| GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code); \
| | ------------------
| | | | 79| 452| do { \
| | | | 80| 452| if (state->successful) { \
| | | | ------------------
| | | | | Branch (80:13): [True: 452, False: 0]
| | | | ------------------
| | | | 81| 452| igraph_i_graphml_sax_handler_error(state, msg); \
| | | | 82| 452| } \
| | | | 83| 452| } while (0)
| | | | ------------------
| | | | | Branch (83:14): [Folded, False: 452]
| | | | ------------------
| | ------------------
| | 87| 452| return; \
| | 88| 452| } while (0)
| | ------------------
| | | Branch (88:14): [Folded, False: 0]
| | ------------------
------------------
1214| 452| }
1215| 4.01M|}
graphml.c:igraph_i_graphml_sax_handler_start_element_ns_inner:
946| 4.01M| int nb_attributes, int nb_defaulted, const xmlChar** attributes) {
947| 4.01M| xmlChar** it;
948| 4.01M| xmlChar* attr_value = 0;
949| 4.01M| igraph_int_t id1, id2;
950| 4.01M| int i;
951| 4.01M| igraph_bool_t tag_is_unknown = false;
952| |
953| 4.01M| IGRAPH_UNUSED(prefix);
------------------
| | 30| 4.01M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
954| 4.01M| IGRAPH_UNUSED(nb_namespaces);
------------------
| | 30| 4.01M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
955| 4.01M| IGRAPH_UNUSED(namespaces);
------------------
| | 30| 4.01M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
956| 4.01M| IGRAPH_UNUSED(nb_defaulted);
------------------
| | 30| 4.01M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
957| |
958| 4.01M| if (uri) {
------------------
| Branch (958:9): [True: 990k, False: 3.02M]
------------------
959| 990k| if (!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), uri)) {
------------------
| | 75| 990k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 990k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (959:13): [True: 6.40k, False: 984k]
------------------
960| | /* Tag is in a different namespace, so treat it as an unknown start
961| | * tag irrespectively of our state */
962| 6.40k| tag_is_unknown = 1;
963| 6.40k| }
964| 3.02M| } 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| 3.02M| if (!state->ignore_namespaces && state->st != START) {
------------------
| Branch (971:13): [True: 2.71M, False: 304k]
| Branch (971:42): [True: 2.71M, False: 6.38k]
------------------
972| 2.71M| tag_is_unknown = 1;
973| 2.71M| }
974| 3.02M| }
975| |
976| 4.01M| if (tag_is_unknown) {
------------------
| Branch (976:9): [True: 2.71M, False: 1.29M]
------------------
977| 2.71M| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 2.71M| do { \
| | 657| 2.71M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.71M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.71M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.71M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.71M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.71M]
| | ------------------
------------------
978| 2.71M| goto exit;
979| 2.71M| }
980| |
981| 1.29M| switch (state->st) {
982| 9.94k| case START:
------------------
| Branch (982:5): [True: 9.94k, False: 1.28M]
------------------
983| | /* If we are in the START state and received a graphml tag,
984| | * change to INSIDE_GRAPHML state. Otherwise, change to UNKNOWN. */
985| 9.94k| if (xmlStrEqual(localname, toXmlChar("graphml"))) {
------------------
| | 75| 9.94k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 9.94k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (985:13): [True: 7.73k, False: 2.21k]
------------------
986| 7.73k| if (uri == 0) {
------------------
| Branch (986:17): [True: 4.17k, False: 3.56k]
------------------
987| 4.17k| state->ignore_namespaces = 1;
988| 4.17k| }
989| 7.73k| state->st = INSIDE_GRAPHML;
990| 7.73k| } else {
991| 2.21k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 2.21k| do { \
| | 657| 2.21k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.21k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.21k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.21k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.21k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.21k]
| | ------------------
------------------
992| 2.21k| }
993| 9.94k| break;
994| |
995| 26.2k| case INSIDE_GRAPHML:
------------------
| Branch (995:5): [True: 26.2k, False: 1.26M]
------------------
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| 26.2k| if (xmlStrEqual(localname, toXmlChar("graph"))) {
------------------
| | 75| 26.2k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 26.2k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1000:13): [True: 8.25k, False: 18.0k]
------------------
1001| 8.25k| if (state->index == 0) {
------------------
| Branch (1001:17): [True: 6.84k, False: 1.40k]
------------------
1002| 6.84k| state->st = INSIDE_GRAPH;
1003| 15.0k| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1003:57): [True: 8.25k, False: 6.84k]
------------------
1004| 8.25k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 8.25k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1004:25): [True: 20, False: 8.23k]
------------------
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.24k| if (xmlStrEqual(*it, toXmlChar("edgedefault"))) {
------------------
| | 75| 8.24k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 8.24k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1009:25): [True: 3.45k, False: 4.78k]
------------------
1010| 3.45k| if (xmlAttrValueEqual(it, "directed")) {
------------------
| Branch (1010:29): [True: 278, False: 3.17k]
------------------
1011| 278| state->edges_directed = 1;
1012| 3.17k| } else if (xmlAttrValueEqual(it, "undirected")) {
------------------
| Branch (1012:36): [True: 3.06k, False: 112]
------------------
1013| 3.06k| state->edges_directed = 0;
1014| 3.06k| }
1015| 3.45k| }
1016| 8.24k| }
1017| 6.84k| }
1018| 8.25k| state->index--;
1019| 18.0k| } else if (xmlStrEqual(localname, toXmlChar("key"))) {
------------------
| | 75| 18.0k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 18.0k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1019:20): [True: 16.9k, False: 1.12k]
------------------
1020| 16.9k| IGRAPH_CHECK(
------------------
| | 656| 16.9k| do { \
| | 657| 16.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 376, False: 16.5k]
| | | | ------------------
| | ------------------
| | 659| 376| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 376| do { \
| | | | 427| 376| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 376| return igraph_errno ; \
| | | | 429| 376| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 376| } \
| | 661| 16.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.5k]
| | ------------------
------------------
1021| 16.9k| igraph_i_graphml_add_attribute_key(
1022| 16.9k| &state->current_attr_record,
1023| 16.9k| attributes, nb_attributes, state
1024| 16.9k| )
1025| 16.9k| );
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.5k| state->st = INSIDE_KEY;
1030| 16.5k| } else {
1031| 1.12k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 1.12k| do { \
| | 657| 1.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.12k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.12k]
| | ------------------
------------------
1032| 1.12k| }
1033| 25.9k| break;
1034| |
1035| 25.9k| case INSIDE_KEY:
------------------
| Branch (1035:5): [True: 4.08k, False: 1.29M]
------------------
1036| | /* If we are in the INSIDE_KEY state and we are not skipping the current
1037| | * attribute, check for default tag */
1038| 4.08k| if (state->current_attr_record != NULL && xmlStrEqual(localname, toXmlChar("default"))) {
------------------
| | 75| 3.74k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 3.74k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1038:13): [True: 3.74k, False: 341]
| Branch (1038:51): [True: 3.50k, False: 235]
------------------
1039| 3.50k| state->st = INSIDE_DEFAULT;
1040| 3.50k| } else {
1041| 576| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 576| do { \
| | 657| 576| igraph_error_t igraph_i_ret = (expr); \
| | 658| 576| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 576| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 576]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 576| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 576]
| | ------------------
------------------
1042| 576| }
1043| 4.08k| break;
1044| |
1045| 4.08k| case INSIDE_DEFAULT:
------------------
| Branch (1045:5): [True: 451, False: 1.29M]
------------------
1046| | /* If we are in the INSIDE_DEFAULT state, every further tag will be unknown */
1047| 451| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 451| do { \
| | 657| 451| igraph_error_t igraph_i_ret = (expr); \
| | 658| 451| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 451| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 451]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 451| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 451]
| | ------------------
------------------
1048| 451| break;
1049| |
1050| 753k| case INSIDE_GRAPH:
------------------
| Branch (1050:5): [True: 753k, False: 541k]
------------------
1051| | /* If we are in the INSIDE_GRAPH state, check for node and edge tags */
1052| 753k| if (xmlStrEqual(localname, toXmlChar("edge"))) {
------------------
| | 75| 753k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 753k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1052:13): [True: 711k, False: 42.0k]
------------------
1053| 711k| id1 = -1; id2 = -1;
1054| 2.27M| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1054:53): [True: 1.56M, False: 711k]
------------------
1055| 1.56M| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 1.56M|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1055:21): [True: 76, False: 1.56M]
------------------
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.56M| if (xmlStrEqual(*it, toXmlChar("source"))) {
------------------
| | 75| 1.56M|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 1.56M|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1060:21): [True: 711k, False: 850k]
------------------
1061| 711k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 711k|#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| 711k| if (attr_value == 0) {
------------------
| Branch (1062:25): [True: 0, False: 711k]
------------------
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| 711k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 711k| do { \
| | 604| 711k| /* the following branch makes the compiler check the compatibility of \
| | 605| 711k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 711k| * incorrect destructor function with the pointer */ \
| | 607| 711k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 711k]
| | ------------------
| | 608| 711k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 711k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 711k]
| | ------------------
------------------
1066| |
1067| 711k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id1));
------------------
| | 656| 711k| do { \
| | 657| 711k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 711k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 711k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 711k]
| | | | ------------------
| | ------------------
| | 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| 711k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 711k]
| | ------------------
------------------
1068| |
1069| 711k| xmlFree(attr_value); attr_value = NULL;
1070| 711k| IGRAPH_FINALLY_CLEAN(1);
1071| 850k| } else if (xmlStrEqual(*it, toXmlChar("target"))) {
------------------
| | 75| 850k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 850k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1071:28): [True: 711k, False: 138k]
------------------
1072| 711k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 711k|#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| 711k| if (attr_value == 0) {
------------------
| Branch (1073:25): [True: 0, False: 711k]
------------------
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| 711k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 711k| do { \
| | 604| 711k| /* the following branch makes the compiler check the compatibility of \
| | 605| 711k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 711k| * incorrect destructor function with the pointer */ \
| | 607| 711k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 711k]
| | ------------------
| | 608| 711k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 711k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 711k]
| | ------------------
------------------
1077| |
1078| 711k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id2));
------------------
| | 656| 711k| do { \
| | 657| 711k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 711k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 711k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 711k]
| | | | ------------------
| | ------------------
| | 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| 711k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 711k]
| | ------------------
------------------
1079| |
1080| 711k| xmlFree(attr_value); attr_value = NULL;
1081| 711k| IGRAPH_FINALLY_CLEAN(1);
1082| 711k| } else if (xmlStrEqual(*it, toXmlChar("id"))) {
------------------
| | 75| 138k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 138k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1082:28): [True: 132k, False: 6.04k]
------------------
1083| 132k| igraph_int_t edges = igraph_vector_int_size(&state->edgelist) / 2 + 1;
1084| 132k| igraph_int_t origsize = igraph_strvector_size(&state->edgeids);
1085| |
1086| 132k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 132k|#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| 132k| if (attr_value == 0) {
------------------
| Branch (1087:25): [True: 0, False: 132k]
------------------
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| 132k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 132k| do { \
| | 604| 132k| /* the following branch makes the compiler check the compatibility of \
| | 605| 132k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 132k| * incorrect destructor function with the pointer */ \
| | 607| 132k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 132k]
| | ------------------
| | 608| 132k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 132k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 132k]
| | ------------------
------------------
1091| |
1092| 132k| IGRAPH_CHECK(igraph_strvector_resize(&state->edgeids, edges));
------------------
| | 656| 132k| do { \
| | 657| 132k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 132k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 132k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 132k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 132k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 132k]
| | ------------------
------------------
1093| |
1094| 173k| for (; origsize < edges - 1; origsize++) {
------------------
| Branch (1094:28): [True: 41.2k, False: 132k]
------------------
1095| 41.2k| IGRAPH_CHECK(igraph_strvector_set(&state->edgeids, origsize, ""));
------------------
| | 656| 41.2k| do { \
| | 657| 41.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 41.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 41.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 41.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| 41.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 41.2k]
| | ------------------
------------------
1096| 41.2k| }
1097| |
1098| 132k| IGRAPH_CHECK(igraph_strvector_set(&state->edgeids, edges - 1, fromXmlChar(attr_value)));
------------------
| | 656| 132k| do { \
| | 657| 132k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 132k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 132k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 132k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 132k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 132k]
| | ------------------
------------------
1099| |
1100| 132k| xmlFree(attr_value); attr_value = NULL;
1101| 132k| IGRAPH_FINALLY_CLEAN(1);
1102| 132k| }
1103| 1.56M| }
1104| 711k| if (id1 >= 0 && id2 >= 0) {
------------------
| Branch (1104:17): [True: 711k, False: 41]
| Branch (1104:29): [True: 711k, False: 12]
------------------
1105| 711k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->edgelist, id1));
------------------
| | 656| 711k| do { \
| | 657| 711k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 711k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 711k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 711k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 711k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 711k]
| | ------------------
------------------
1106| 711k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->edgelist, id2));
------------------
| | 656| 711k| do { \
| | 657| 711k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 711k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 711k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 711k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 711k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 711k]
| | ------------------
------------------
1107| 711k| } else {
1108| 53| IGRAPH_ERROR("Edge with missing source or target encountered.", IGRAPH_PARSEERROR);
------------------
| | 426| 53| do { \
| | 427| 53| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 53| return igraph_errno ; \
| | 429| 53| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1109| 53| }
1110| 711k| state->st = INSIDE_EDGE;
1111| 711k| } else if (xmlStrEqual(localname, toXmlChar("node"))) {
------------------
| | 75| 42.0k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 42.0k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1111:20): [True: 33.7k, False: 8.32k]
------------------
1112| 33.7k| id1 = -1;
1113| 34.4k| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1113:53): [True: 34.4k, False: 19]
------------------
1114| 34.4k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 34.4k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1114:21): [True: 209, False: 34.2k]
------------------
1115| 209| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 209|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 209|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 209|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1115:21): [True: 199, False: 10]
------------------
1116| | /* Attribute is from a different namespace, so skip it */
1117| 199| continue;
1118| 199| }
1119| 34.2k| if (xmlStrEqual(XML_ATTR_LOCALNAME(it), toXmlChar("id"))) {
------------------
| | 495| 34.2k|#define XML_ATTR_LOCALNAME(it) it[0]
------------------
if (xmlStrEqual(XML_ATTR_LOCALNAME(it), toXmlChar("id"))) {
------------------
| | 75| 34.2k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 34.2k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1119:21): [True: 33.7k, False: 513]
------------------
1120| 33.7k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 33.7k|#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| 33.7k| if (attr_value == 0) {
------------------
| Branch (1121:25): [True: 0, False: 33.7k]
------------------
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| 33.7k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 33.7k| do { \
| | 604| 33.7k| /* the following branch makes the compiler check the compatibility of \
| | 605| 33.7k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 33.7k| * incorrect destructor function with the pointer */ \
| | 607| 33.7k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 33.7k]
| | ------------------
| | 608| 33.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 33.7k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 33.7k]
| | ------------------
------------------
1125| |
1126| 33.7k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id1));
------------------
| | 656| 33.7k| do { \
| | 657| 33.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 33.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 33.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 2, False: 33.6k]
| | | | ------------------
| | ------------------
| | 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| 33.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 33.6k]
| | ------------------
------------------
1127| |
1128| 33.6k| xmlFree(attr_value); attr_value = NULL;
1129| 33.6k| IGRAPH_FINALLY_CLEAN(1);
1130| 33.6k| break;
1131| 33.7k| }
1132| 34.2k| }
1133| 33.7k| if (id1 >= 0) {
------------------
| Branch (1133:17): [True: 33.6k, False: 19]
------------------
1134| 33.6k| state->act_node = id1;
1135| 33.6k| } else {
1136| 19| state->act_node = -1;
1137| 19| IGRAPH_ERROR("Node with missing ID encountered.", IGRAPH_PARSEERROR);
------------------
| | 426| 19| do { \
| | 427| 19| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 19| return igraph_errno ; \
| | 429| 19| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1138| 19| }
1139| 33.6k| state->st = INSIDE_NODE;
1140| 33.6k| } else if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 8.32k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 8.32k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1140:20): [True: 3.36k, False: 4.96k]
------------------
1141| 3.36k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 656| 3.36k| do { \
| | 657| 3.36k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.36k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.36k]
| | ------------------
------------------
1142| 3.36k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_GRAPH
1143| 3.36k| ));
1144| 3.36k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 3.36k| do { \
| | 657| 3.36k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.36k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.36k]
| | ------------------
------------------
1145| 3.36k| state->st = INSIDE_DATA;
1146| 4.96k| } else {
1147| 4.96k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 4.96k| do { \
| | 657| 4.96k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.96k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.96k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.96k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.96k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.96k]
| | ------------------
------------------
1148| 4.96k| }
1149| 753k| break;
1150| |
1151| 753k| case INSIDE_NODE:
------------------
| Branch (1151:5): [True: 50.9k, False: 1.24M]
------------------
1152| 50.9k| if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 50.9k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 50.9k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1152:13): [True: 50.6k, False: 288]
------------------
1153| 50.6k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 656| 50.6k| do { \
| | 657| 50.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 50.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 50.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 50.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| 50.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 50.6k]
| | ------------------
------------------
1154| 50.6k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_VERTEX
1155| 50.6k| ));
1156| 50.6k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 50.6k| do { \
| | 657| 50.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 50.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 50.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 50.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| 50.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 50.6k]
| | ------------------
------------------
1157| 50.6k| state->st = INSIDE_DATA;
1158| 50.6k| } else {
1159| 288| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 288| do { \
| | 657| 288| igraph_error_t igraph_i_ret = (expr); \
| | 658| 288| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 288| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 288]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 288| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 288]
| | ------------------
------------------
1160| 288| }
1161| 50.9k| break;
1162| |
1163| 355k| case INSIDE_EDGE:
------------------
| Branch (1163:5): [True: 355k, False: 939k]
------------------
1164| 355k| if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 355k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 355k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1164:13): [True: 354k, False: 486]
------------------
1165| 354k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 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]
| | ------------------
------------------
1166| 354k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_EDGE
1167| 354k| ));
1168| 354k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 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]
| | ------------------
------------------
1169| 354k| state->st = INSIDE_DATA;
1170| 354k| } else {
1171| 486| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 486| do { \
| | 657| 486| igraph_error_t igraph_i_ret = (expr); \
| | 658| 486| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 486| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 486]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 486| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 486]
| | ------------------
------------------
1172| 486| }
1173| 355k| break;
1174| |
1175| 355k| case INSIDE_DATA:
------------------
| Branch (1175:5): [True: 282, False: 1.29M]
------------------
1176| | /* We do not expect any new tags within a tag */
1177| 282| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 282| do { \
| | 657| 282| igraph_error_t igraph_i_ret = (expr); \
| | 658| 282| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 282| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 282]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 282| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 282]
| | ------------------
------------------
1178| 282| break;
1179| |
1180| 92.7k| case UNKNOWN:
------------------
| Branch (1180:5): [True: 92.7k, False: 1.20M]
------------------
1181| 92.7k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 92.7k| do { \
| | 657| 92.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 92.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 92.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 92.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| 92.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 92.7k]
| | ------------------
------------------
1182| 92.7k| break;
1183| |
1184| 92.7k| case FINISH:
------------------
| Branch (1184:5): [True: 1.06k, False: 1.29M]
------------------
1185| 1.06k| break;
1186| |
1187| 0| default:
------------------
| Branch (1187:5): [True: 0, False: 1.29M]
------------------
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.29M| }
1190| |
1191| 4.01M|exit:
1192| 4.01M| return IGRAPH_SUCCESS;
1193| 1.29M|}
graphml.c:igraph_i_graphml_handle_unknown_start_tag:
366| 2.81M|static igraph_error_t igraph_i_graphml_handle_unknown_start_tag(struct igraph_i_graphml_parser_state *state) {
367| 2.81M| if (state->st != UNKNOWN) {
------------------
| Branch (367:9): [True: 10.6k, False: 2.80M]
------------------
368| 10.6k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 10.6k| do { \
| | 657| 10.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10.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| 10.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.6k]
| | ------------------
------------------
369| 10.6k| state->st = UNKNOWN;
370| 10.6k| state->unknown_depth = 1;
371| 2.80M| } else {
372| 2.80M| state->unknown_depth++;
373| 2.80M| }
374| 2.81M| return IGRAPH_SUCCESS;
375| 2.81M|}
graphml.c:xmlAttrValueEqual:
532| 78.3k|static igraph_bool_t xmlAttrValueEqual(xmlChar** attr, const char* expected) {
533| 78.3k| size_t expected_length = strlen(expected);
534| 78.3k| return (
535| 78.3k| expected_length == XML_ATTR_VALUE_LENGTH(attr) &&
------------------
| | 500| 156k|#define XML_ATTR_VALUE_LENGTH(it) (size_t)(it[4] - it[3])
------------------
| Branch (535:9): [True: 41.3k, False: 36.9k]
------------------
536| 41.3k| !xmlStrncmp(toXmlChar(expected), XML_ATTR_VALUE(attr))
------------------
| | 75| 41.3k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 41.3k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrncmp(toXmlChar(expected), XML_ATTR_VALUE(attr))
------------------
| | 501| 41.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 */
------------------
| Branch (536:9): [True: 32.6k, False: 8.69k]
------------------
537| 78.3k| );
538| 78.3k|}
graphml.c:igraph_i_graphml_add_attribute_key:
544| 16.9k|) {
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| 16.9k| xmlChar **it;
559| 16.9k| xmlChar *localname;
560| 16.9k| igraph_trie_t *trie = NULL;
561| 16.9k| igraph_vector_ptr_t *ptrvector = NULL;
562| 16.9k| igraph_int_t i, n;
563| 16.9k| igraph_int_t id;
564| 16.9k| igraph_i_graphml_attribute_record_t *rec = NULL;
565| 16.9k| char *attr_name;
566| 16.9k| igraph_attribute_type_t igraph_attr_type;
567| 16.9k| igraph_bool_t skip = false;
568| |
569| 16.9k| attr_name = NULL;
570| 16.9k| IGRAPH_FINALLY(safely_free_optional_string, &attr_name);
------------------
| | 603| 16.9k| do { \
| | 604| 16.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.9k| * incorrect destructor function with the pointer */ \
| | 607| 16.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.9k]
| | ------------------
| | 608| 16.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.9k]
| | ------------------
------------------
571| |
572| 16.9k| if (!state->successful) {
------------------
| Branch (572:9): [True: 0, False: 16.9k]
------------------
573| | /* Parser is already in an error state */
574| 0| goto exit;
575| 0| }
576| |
577| 16.9k| rec = IGRAPH_CALLOC(1, igraph_i_graphml_attribute_record_t);
------------------
| | 33| 16.9k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 33.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.9k, Folded]
| | | | ------------------
| | ------------------
------------------
578| 16.9k| IGRAPH_CHECK_OOM(rec, "Insufficient memory to allocate attribute record.");
------------------
| | 709| 16.9k| do { \
| | 710| 16.9k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 16.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.9k]
| | | | ------------------
| | ------------------
| | 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.9k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 16.9k]
| | ------------------
------------------
579| 16.9k| IGRAPH_FINALLY(igraph_free, rec);
------------------
| | 603| 16.9k| do { \
| | 604| 16.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.9k| * incorrect destructor function with the pointer */ \
| | 607| 16.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.9k]
| | ------------------
| | 608| 16.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.9k]
| | ------------------
------------------
580| 16.9k| IGRAPH_FINALLY(igraph_i_graphml_attribute_record_destroy, rec);
------------------
| | 603| 16.9k| do { \
| | 604| 16.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 16.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 16.9k| * incorrect destructor function with the pointer */ \
| | 607| 16.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 16.9k]
| | ------------------
| | 608| 16.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 16.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 16.9k]
| | ------------------
------------------
581| 16.9k| memset(rec, 0, sizeof(igraph_i_graphml_attribute_record_t));
582| |
583| 16.9k| igraph_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
584| |
585| 76.5k| for (i = 0, it = (xmlChar**)attrs; i < nb_attrs; i++, it += 5) {
------------------
| Branch (585:40): [True: 59.8k, False: 16.6k]
------------------
586| 59.8k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 59.8k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (586:13): [True: 495, False: 59.3k]
------------------
587| 495| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 495|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 495|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 495|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (587:13): [True: 428, False: 67]
------------------
588| 428| continue;
589| 428| }
590| |
591| 59.4k| localname = XML_ATTR_LOCALNAME(it);
------------------
| | 495| 59.4k|#define XML_ATTR_LOCALNAME(it) it[0]
------------------
592| |
593| 59.4k| if (xmlStrEqual(localname, toXmlChar("id"))) {
------------------
| | 75| 59.4k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 59.4k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (593:13): [True: 16.7k, False: 42.7k]
------------------
594| 16.7k| safely_free_optional_string(&rec->id);
595| 16.7k| IGRAPH_CHECK(safely_convert_xml_attribute_to_string(it, &rec->id));
------------------
| | 656| 16.7k| do { \
| | 657| 16.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.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| 16.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16.7k]
| | ------------------
------------------
596| 42.7k| } else if (xmlStrEqual(localname, toXmlChar("attr.name"))) {
------------------
| | 75| 42.7k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 42.7k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (596:20): [True: 9.85k, False: 32.8k]
------------------
597| 9.85k| safely_free_optional_string(&attr_name);
598| 9.85k| IGRAPH_CHECK(safely_convert_xml_attribute_to_string(it, &attr_name));
------------------
| | 656| 9.85k| do { \
| | 657| 9.85k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 9.85k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 9.85k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.85k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.85k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 9.85k]
| | ------------------
------------------
599| 32.8k| } else if (xmlStrEqual(localname, toXmlChar("attr.type"))) {
------------------
| | 75| 32.8k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 32.8k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (599:20): [True: 14.1k, False: 18.7k]
------------------
600| 14.1k| if (xmlAttrValueEqual(it, "boolean")) {
------------------
| Branch (600:17): [True: 2.40k, False: 11.7k]
------------------
601| 2.40k| igraph_attr_type = IGRAPH_ATTRIBUTE_BOOLEAN;
602| 2.40k| rec->type = I_GRAPHML_BOOLEAN;
603| 11.7k| } else if (xmlAttrValueEqual(it, "string")) {
------------------
| Branch (603:24): [True: 9.20k, False: 2.57k]
------------------
604| 9.20k| igraph_attr_type = IGRAPH_ATTRIBUTE_STRING;
605| 9.20k| rec->type = I_GRAPHML_STRING;
606| 9.20k| } else if (xmlAttrValueEqual(it, "float")) {
------------------
| Branch (606:24): [True: 209, False: 2.36k]
------------------
607| 209| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
608| 209| rec->type = I_GRAPHML_FLOAT;
609| 2.36k| } else if (xmlAttrValueEqual(it, "double")) {
------------------
| Branch (609:24): [True: 1.99k, False: 375]
------------------
610| 1.99k| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
611| 1.99k| rec->type = I_GRAPHML_DOUBLE;
612| 1.99k| } else if (xmlAttrValueEqual(it, "int")) {
------------------
| Branch (612:24): [True: 224, False: 151]
------------------
613| 224| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
614| 224| rec->type = I_GRAPHML_INTEGER;
615| 224| } else if (xmlAttrValueEqual(it, "long")) {
------------------
| Branch (615:24): [True: 70, False: 81]
------------------
616| 70| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
617| 70| rec->type = I_GRAPHML_LONG;
618| 81| } else {
619| 81| IGRAPH_ERRORF("Unknown attribute type '%.*s'.", IGRAPH_PARSEERROR,
------------------
| | 464| 81| do { \
| | 465| 81| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 81| igraph_errno, __VA_ARGS__) ; \
| | 467| 81| return igraph_errno; \
| | 468| 81| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
620| 81| XML_ATTR_VALUE_PF(it));
621| 81| }
622| 18.7k| } else if (xmlStrEqual(*it, toXmlChar("for"))) {
------------------
| | 75| 18.7k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 18.7k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (622:20): [True: 15.3k, False: 3.32k]
------------------
623| | /* graph, vertex or edge attribute? */
624| 15.3k| if (xmlAttrValueEqual(it, "graph")) {
------------------
| Branch (624:17): [True: 1.89k, False: 13.4k]
------------------
625| 1.89k| trie = &state->g_attr_ids;
626| 1.89k| ptrvector = &state->g_attrs;
627| 13.4k| } else if (xmlAttrValueEqual(it, "node")) {
------------------
| Branch (627:24): [True: 7.05k, False: 6.43k]
------------------
628| 7.05k| trie = &state->v_attr_ids;
629| 7.05k| ptrvector = &state->v_attrs;
630| 7.05k| } else if (xmlAttrValueEqual(it, "edge")) {
------------------
| Branch (630:24): [True: 4.91k, False: 1.52k]
------------------
631| 4.91k| trie = &state->e_attr_ids;
632| 4.91k| ptrvector = &state->e_attrs;
633| 4.91k| } else if (xmlAttrValueEqual(it, "graphml")) {
------------------
| Branch (633:24): [True: 229, False: 1.29k]
------------------
634| 229| igraph_i_report_unhandled_attribute_target("graphml", IGRAPH_FILE_BASENAME, __LINE__);
635| 229| skip = 1;
636| 1.29k| } else if (xmlAttrValueEqual(it, "hyperedge")) {
------------------
| Branch (636:24): [True: 73, False: 1.22k]
------------------
637| 73| igraph_i_report_unhandled_attribute_target("hyperedge", IGRAPH_FILE_BASENAME, __LINE__);
638| 73| skip = 1;
639| 1.22k| } else if (xmlAttrValueEqual(it, "port")) {
------------------
| Branch (639:24): [True: 666, False: 555]
------------------
640| 666| igraph_i_report_unhandled_attribute_target("port", IGRAPH_FILE_BASENAME, __LINE__);
641| 666| skip = 1;
642| 666| } else if (xmlAttrValueEqual(it, "endpoint")) {
------------------
| Branch (642:24): [True: 196, False: 359]
------------------
643| 196| igraph_i_report_unhandled_attribute_target("endpoint", IGRAPH_FILE_BASENAME, __LINE__);
644| 196| skip = 1;
645| 359| } else if (xmlAttrValueEqual(it, "all")) {
------------------
| Branch (645:24): [True: 180, False: 179]
------------------
646| | /* TODO: we should handle this */
647| 180| igraph_i_report_unhandled_attribute_target("all", IGRAPH_FILE_BASENAME, __LINE__);
648| 180| skip = 1;
649| 180| } else {
650| 179| IGRAPH_ERRORF("Unknown value '%.*s' in the 'for' attribute of a tag.", IGRAPH_PARSEERROR,
------------------
| | 464| 179| do { \
| | 465| 179| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 179| igraph_errno, __VA_ARGS__) ; \
| | 467| 179| return igraph_errno; \
| | 468| 179| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
651| 179| XML_ATTR_VALUE_PF(it));
652| 179| }
653| 15.3k| }
654| 59.4k| }
655| |
656| | /* throw an error if there is no ID; this is a clear violation of the GraphML DTD */
657| 16.6k| if (rec->id == NULL) {
------------------
| Branch (657:9): [True: 65, False: 16.5k]
------------------
658| 65| IGRAPH_ERROR("Found tag with no 'id' attribute.", IGRAPH_PARSEERROR);
------------------
| | 426| 65| do { \
| | 427| 65| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 65| return igraph_errno ; \
| | 429| 65| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
659| 65| }
660| |
661| | /* throw an error if the ID is an empty string; this is also a clear violation of the GraphML DTD */
662| 16.5k| if (*(rec->id) == '\0') {
------------------
| Branch (662:9): [True: 45, False: 16.5k]
------------------
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.5k| if (attr_name == NULL) {
------------------
| Branch (667:9): [True: 6.73k, False: 9.81k]
------------------
668| | /* Allocation here is protected by safely_free_optional_string(&attr_name),
669| | * which is already in the finally stack */
670| 6.73k| attr_name = strdup(rec->id);
671| 6.73k| IGRAPH_CHECK_OOM(attr_name, "Cannot duplicate attribute ID as name.");
------------------
| | 709| 6.73k| do { \
| | 710| 6.73k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 6.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.73k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 6.73k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 6.73k]
| | ------------------
------------------
672| 6.73k| }
673| |
674| | /* if the attribute type is missing, ignore the attribute with a warning */
675| 16.5k| if (!skip && rec->type == I_GRAPHML_UNKNOWN_TYPE) {
------------------
| Branch (675:9): [True: 15.2k, False: 1.32k]
| Branch (675:18): [True: 0, False: 15.2k]
------------------
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.5k| if (!skip && trie == 0) {
------------------
| Branch (681:9): [True: 15.2k, False: 1.32k]
| Branch (681:18): [True: 1.44k, False: 13.7k]
------------------
682| 1.44k| IGRAPH_WARNINGF("Ignoring because of a missing 'for' attribute.", rec->id);
------------------
| | 777| 1.44k| do { \
| | 778| 1.44k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 1.44k| __VA_ARGS__); \
| | 780| 1.44k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 1.44k]
| | ------------------
------------------
683| 1.44k| skip = 1;
684| 1.44k| }
685| |
686| | /* If attribute is skipped, proceed according to the type of the associated graph element. */
687| 16.5k| if (skip) {
------------------
| Branch (687:9): [True: 2.77k, False: 13.7k]
------------------
688| 2.77k| if (trie == 0) {
------------------
| Branch (688:13): [True: 2.77k, False: 0]
------------------
689| | /* Attribute was skipped because it is not for a node, edge or the graph.
690| | * Free everything and return. */
691| 2.77k| if (rec) {
------------------
| Branch (691:17): [True: 2.77k, False: 0]
------------------
692| 2.77k| igraph_i_graphml_attribute_record_destroy(rec);
693| 2.77k| IGRAPH_FREE(rec);
------------------
| | 36| 2.77k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
694| 2.77k| }
695| 2.77k| IGRAPH_FINALLY_CLEAN(2);
696| 2.77k| goto exit;
697| 2.77k| } 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.77k| }
704| |
705| | /* check if we have already seen this ID */
706| 13.7k| IGRAPH_CHECK(igraph_trie_check(trie, rec->id, &id));
------------------
| | 656| 13.7k| do { \
| | 657| 13.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.7k]
| | ------------------
------------------
707| 13.7k| if (id >= 0) {
------------------
| Branch (707:9): [True: 5, False: 13.7k]
------------------
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| 13.7k| n = igraph_vector_ptr_size(ptrvector);
713| 31.6k| for (i = 0; i < n; i++) {
------------------
| Branch (713:17): [True: 17.8k, False: 13.7k]
------------------
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| 13.7k| IGRAPH_CHECK(igraph_trie_get(trie, rec->id, &id));
------------------
| | 656| 13.7k| do { \
| | 657| 13.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.7k]
| | ------------------
------------------
727| 13.7k| IGRAPH_CHECK(igraph_vector_ptr_push_back(ptrvector, rec));
------------------
| | 656| 13.7k| do { \
| | 657| 13.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.7k]
| | ------------------
------------------
728| |
729| | /* Ownership of 'rec' is now taken by ptrvector so we are not responsible
730| | * for destroying and freeing it any more */
731| 13.7k| IGRAPH_FINALLY_CLEAN(2);
732| |
733| | /* create the attribute values */
734| 13.7k| IGRAPH_CHECK(igraph_attribute_record_init(&rec->record, attr_name, igraph_attr_type));
------------------
| | 656| 13.7k| do { \
| | 657| 13.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.7k]
| | ------------------
------------------
735| |
736| 16.5k|exit:
737| 16.5k| safely_free_optional_string(&attr_name);
738| 16.5k| IGRAPH_FINALLY_CLEAN(1);
739| |
740| 16.5k| *record = rec;
741| 16.5k| return IGRAPH_SUCCESS;
742| 13.7k|}
graphml.c:safely_free_optional_string:
525| 43.4k|static void safely_free_optional_string(char** str) {
526| 43.4k| if (*str != NULL) {
------------------
| Branch (526:9): [True: 16.5k, False: 26.8k]
------------------
527| 16.5k| igraph_free(*str);
528| | *str = NULL;
529| 16.5k| }
530| 43.4k|}
graphml.c:safely_convert_xml_attribute_to_string:
504| 26.5k|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| 26.5k| xmlChar *xml_str;
508| 26.5k| char *c_str;
509| |
510| 26.5k| xml_str = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 26.5k|#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| 26.5k| IGRAPH_CHECK_OOM(xml_str, "Insufficient memory to duplicate attribute value.");
------------------
| | 709| 26.5k| do { \
| | 710| 26.5k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 26.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 26.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| 26.5k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 26.5k]
| | ------------------
------------------
512| 26.5k| IGRAPH_FINALLY(xmlFree, xml_str);
------------------
| | 603| 26.5k| do { \
| | 604| 26.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 26.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 26.5k| * incorrect destructor function with the pointer */ \
| | 607| 26.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 26.5k]
| | ------------------
| | 608| 26.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 26.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 26.5k]
| | ------------------
------------------
513| |
514| 26.5k| c_str = strdup(fromXmlChar(xml_str));
------------------
| | 76| 26.5k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
515| 26.5k| IGRAPH_CHECK_OOM(c_str, "Insufficient memory to duplicate attribute value.");
------------------
| | 709| 26.5k| do { \
| | 710| 26.5k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 26.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 26.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| 26.5k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 26.5k]
| | ------------------
------------------
516| |
517| 26.5k| *str = c_str;
518| |
519| 26.5k| xmlFree(xml_str);
520| 26.5k| IGRAPH_FINALLY_CLEAN(1);
521| |
522| 26.5k| return IGRAPH_SUCCESS;
523| 26.5k|}
graphml.c:igraph_i_report_unhandled_attribute_target:
132| 1.34k| const char* file, int line) {
133| 1.34k| igraph_warningf("Attribute target '%s' is not handled; ignoring corresponding "
134| 1.34k| "attribute specifications.", file, line, target);
135| 1.34k|}
graphml.c:igraph_i_graphml_attribute_data_setup:
747| 408k|) {
748| 408k| xmlChar **it;
749| 408k| int i;
750| |
751| 408k| if (!state->successful) {
------------------
| Branch (751:9): [True: 0, False: 408k]
------------------
752| 0| return IGRAPH_SUCCESS;
753| 0| }
754| |
755| 816k| for (i = 0, it = (xmlChar**)attrs; i < nb_attrs; i++, it += 5) {
------------------
| Branch (755:40): [True: 407k, False: 408k]
------------------
756| 407k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 407k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (756:13): [True: 76, False: 407k]
------------------
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| 407k| if (xmlStrEqual(*it, toXmlChar("key"))) {
------------------
| | 75| 407k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 407k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (761:13): [True: 407k, False: 543]
------------------
762| 407k| if (state->data_key) {
------------------
| Branch (762:17): [True: 403k, False: 3.41k]
------------------
763| 403k| xmlFree((void *) state->data_key);
764| 403k| state->data_key = NULL;
765| 403k| }
766| 407k| state->data_key = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 407k|#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| 407k| IGRAPH_CHECK_OOM(state->data_key, "Insufficient memory to read GraphML file.");
------------------
| | 709| 407k| do { \
| | 710| 407k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 407k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 407k]
| | | | ------------------
| | ------------------
| | 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| 407k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 407k]
| | ------------------
------------------
768| 407k| igraph_vector_char_clear(&state->data_char);
769| 407k| state->data_type = type;
770| 407k| } else {
771| | /* ignore */
772| 543| }
773| 407k| }
774| |
775| 408k| return IGRAPH_SUCCESS;
776| 408k|}
graphml.c:igraph_i_graphml_sax_handler_end_element_ns:
1280| 1.28M| const xmlChar* uri) {
1281| 1.28M| struct igraph_i_graphml_parser_state *state =
1282| 1.28M| (struct igraph_i_graphml_parser_state*)state0;
1283| 1.28M| igraph_error_t result;
1284| |
1285| 1.28M| if (!state->successful) {
------------------
| Branch (1285:9): [True: 6.35k, False: 1.27M]
------------------
1286| 6.35k| return;
1287| 6.35k| }
1288| |
1289| 1.27M| result = igraph_i_graphml_sax_handler_end_element_ns_inner(
1290| 1.27M| state, localname, prefix, uri
1291| 1.27M| );
1292| |
1293| 1.27M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1293:9): [True: 93, False: 1.27M]
------------------
1294| 93| RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file.", result);
------------------
| | 85| 93| do { \
| | 86| 93| GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code); \
| | ------------------
| | | | 79| 93| do { \
| | | | 80| 93| if (state->successful) { \
| | | | ------------------
| | | | | Branch (80:13): [True: 93, False: 0]
| | | | ------------------
| | | | 81| 93| igraph_i_graphml_sax_handler_error(state, msg); \
| | | | 82| 93| } \
| | | | 83| 93| } while (0)
| | | | ------------------
| | | | | Branch (83:14): [Folded, False: 93]
| | | | ------------------
| | ------------------
| | 87| 93| return; \
| | 88| 93| } while (0)
| | ------------------
| | | Branch (88:14): [Folded, False: 0]
| | ------------------
------------------
1295| 93| }
1296| 1.27M|}
graphml.c:igraph_i_graphml_sax_handler_end_element_ns_inner:
1221| 1.27M|) {
1222| 1.27M| IGRAPH_UNUSED(localname);
------------------
| | 30| 1.27M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1223| 1.27M| IGRAPH_UNUSED(prefix);
------------------
| | 30| 1.27M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1224| 1.27M| IGRAPH_UNUSED(uri);
------------------
| | 30| 1.27M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1225| |
1226| 1.27M| switch (state->st) {
1227| 6.33k| case INSIDE_GRAPHML:
------------------
| Branch (1227:5): [True: 6.33k, False: 1.26M]
------------------
1228| 6.33k| state->st = FINISH;
1229| 6.33k| break;
1230| |
1231| 6.36k| case INSIDE_GRAPH:
------------------
| Branch (1231:5): [True: 6.36k, False: 1.26M]
------------------
1232| 6.36k| state->st = INSIDE_GRAPHML;
1233| 6.36k| break;
1234| |
1235| 16.2k| case INSIDE_KEY:
------------------
| Branch (1235:5): [True: 16.2k, False: 1.25M]
------------------
1236| 16.2k| state->current_attr_record = NULL;
1237| 16.2k| state->st = INSIDE_GRAPHML;
1238| 16.2k| break;
1239| |
1240| 3.46k| case INSIDE_DEFAULT:
------------------
| Branch (1240:5): [True: 3.46k, False: 1.27M]
------------------
1241| 3.46k| IGRAPH_CHECK(igraph_i_graphml_attribute_default_value_finish(state));
------------------
| | 656| 3.46k| do { \
| | 657| 3.46k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.46k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.46k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 66, False: 3.40k]
| | | | ------------------
| | ------------------
| | 659| 66| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 66| do { \
| | | | 427| 66| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 66| return igraph_errno ; \
| | | | 429| 66| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 66| } \
| | 661| 3.46k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.40k]
| | ------------------
------------------
1242| 3.40k| state->st = INSIDE_KEY;
1243| 3.40k| break;
1244| |
1245| 33.6k| case INSIDE_NODE:
------------------
| Branch (1245:5): [True: 33.6k, False: 1.24M]
------------------
1246| 33.6k| state->st = INSIDE_GRAPH;
1247| 33.6k| break;
1248| |
1249| 711k| case INSIDE_EDGE:
------------------
| Branch (1249:5): [True: 711k, False: 562k]
------------------
1250| 711k| state->st = INSIDE_GRAPH;
1251| 711k| break;
1252| |
1253| 408k| case INSIDE_DATA:
------------------
| Branch (1253:5): [True: 408k, False: 865k]
------------------
1254| 408k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_finish(state));
------------------
| | 656| 408k| do { \
| | 657| 408k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 408k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 408k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 27, False: 408k]
| | | | ------------------
| | ------------------
| | 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| 408k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 408k]
| | ------------------
------------------
1255| 408k| IGRAPH_ASSERT(!igraph_vector_int_empty(&state->prev_state_stack));
------------------
| | 924| 408k| do { \
| | 925| 408k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 408k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 408k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 408k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 408k]
| | ------------------
------------------
1256| 408k| state->st = (igraph_i_graphml_parser_state_index_t) igraph_vector_int_pop_back(&state->prev_state_stack);
1257| 408k| break;
1258| |
1259| 86.2k| case UNKNOWN:
------------------
| Branch (1259:5): [True: 86.2k, False: 1.18M]
------------------
1260| 86.2k| state->unknown_depth--;
1261| 86.2k| if (!state->unknown_depth) {
------------------
| Branch (1261:13): [True: 8.27k, False: 77.9k]
------------------
1262| 8.27k| IGRAPH_ASSERT(!igraph_vector_int_empty(&state->prev_state_stack));
------------------
| | 924| 8.27k| do { \
| | 925| 8.27k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.27k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.27k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.27k]
| | ------------------
------------------
1263| 8.27k| state->st = (igraph_i_graphml_parser_state_index_t) igraph_vector_int_pop_back(&state->prev_state_stack);
1264| 8.27k| }
1265| 86.2k| break;
1266| |
1267| 86.2k| case FINISH:
------------------
| Branch (1267:5): [True: 1.36k, False: 1.27M]
------------------
1268| 1.36k| break;
1269| |
1270| 0| default:
------------------
| Branch (1270:5): [True: 0, False: 1.27M]
------------------
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.27M| }
1273| |
1274| 1.27M| return IGRAPH_SUCCESS;
1275| 1.27M|}
graphml.c:igraph_i_graphml_attribute_default_value_finish:
899| 3.46k|static igraph_error_t igraph_i_graphml_attribute_default_value_finish(struct igraph_i_graphml_parser_state *state) {
900| 3.46k| igraph_i_graphml_attribute_record_t *graphmlrec = state->current_attr_record;
901| 3.46k| igraph_attribute_record_t *rec;
902| 3.46k| igraph_error_t result = IGRAPH_SUCCESS;
903| 3.46k| igraph_real_t default_num;
904| 3.46k| igraph_bool_t default_bool;
905| |
906| 3.46k| IGRAPH_ASSERT(state->current_attr_record != NULL);
------------------
| | 924| 3.46k| do { \
| | 925| 3.46k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.46k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.46k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.46k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.46k]
| | ------------------
------------------
907| |
908| 3.46k| if (igraph_vector_char_size(&state->data_char) == 0) {
------------------
| Branch (908:9): [True: 243, False: 3.22k]
------------------
909| 243| return IGRAPH_SUCCESS;
910| 243| }
911| |
912| 3.22k| rec = &graphmlrec->record;
913| |
914| 3.22k| switch (rec->type) {
915| 1.52k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (915:5): [True: 1.52k, False: 1.69k]
------------------
916| | /* Add null terminator */
917| 1.52k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 1.52k| do { \
| | 657| 1.52k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.52k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.52k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.52k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.52k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.52k]
| | ------------------
------------------
918| 1.52k| IGRAPH_CHECK(igraph_i_graphml_parse_boolean(VECTOR(state->data_char), &default_bool, false));
------------------
| | 656| 1.52k| do { \
| | 657| 1.52k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.52k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.52k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 62, False: 1.46k]
| | | | ------------------
| | ------------------
| | 659| 62| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 62| do { \
| | | | 427| 62| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 62| return igraph_errno ; \
| | | | 429| 62| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 62| } \
| | 661| 1.52k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.46k]
| | ------------------
------------------
919| 1.46k| IGRAPH_CHECK(igraph_attribute_record_set_default_boolean(rec, default_bool));
------------------
| | 656| 1.46k| do { \
| | 657| 1.46k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.46k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.46k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.46k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.46k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.46k]
| | ------------------
------------------
920| 1.46k| break;
921| 1.46k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (921:5): [True: 480, False: 2.74k]
------------------
922| | /* Add null terminator */
923| 480| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 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]
| | ------------------
------------------
924| 480| IGRAPH_CHECK(igraph_i_graphml_parse_numeric(VECTOR(state->data_char), &default_num, IGRAPH_NAN));
------------------
| | 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: 4, False: 476]
| | | | ------------------
| | ------------------
| | 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| 480| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 476]
| | ------------------
------------------
925| 476| IGRAPH_CHECK(igraph_attribute_record_set_default_numeric(rec, default_num));
------------------
| | 656| 476| do { \
| | 657| 476| igraph_error_t igraph_i_ret = (expr); \
| | 658| 476| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 476| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 476]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 476| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 476]
| | ------------------
------------------
926| 476| break;
927| 970| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (927:5): [True: 970, False: 2.25k]
------------------
928| | /* Add null terminator */
929| 970| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 970| do { \
| | 657| 970| igraph_error_t igraph_i_ret = (expr); \
| | 658| 970| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 970| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 970]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 970| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 970]
| | ------------------
------------------
930| 970| IGRAPH_CHECK(igraph_attribute_record_set_default_string(rec, VECTOR(state->data_char)));
------------------
| | 656| 970| do { \
| | 657| 970| igraph_error_t igraph_i_ret = (expr); \
| | 658| 970| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 970| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 970]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 970| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 970]
| | ------------------
------------------
931| 970| break;
932| 970| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (932:5): [True: 246, False: 2.97k]
------------------
933| 246| break;
934| 0| default:
------------------
| Branch (934:5): [True: 0, False: 3.22k]
------------------
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.22k| }
937| |
938| 3.15k| igraph_vector_char_clear(&state->data_char);
939| |
940| 3.15k| return result;
941| 3.22k|}
graphml.c:igraph_i_graphml_parse_boolean:
160| 11.6k|) {
161| 11.6k| igraph_int_t value;
162| 11.6k| const char* trimmed;
163| 11.6k| size_t trimmed_length;
164| |
165| 11.6k| if (char_data == 0) {
------------------
| Branch (165:9): [True: 0, False: 11.6k]
------------------
166| 0| *result = default_value;
167| 0| return IGRAPH_SUCCESS;
168| 0| }
169| |
170| 11.6k| igraph_i_trim_whitespace(char_data, strlen(char_data), &trimmed, &trimmed_length);
171| |
172| 11.6k| if (trimmed_length == 4 && !strncasecmp(trimmed, "true", trimmed_length)) {
------------------
| Branch (172:9): [True: 548, False: 11.1k]
| Branch (172:32): [True: 225, False: 323]
------------------
173| 225| *result = 1;
174| 225| return IGRAPH_SUCCESS;
175| 225| }
176| |
177| 11.4k| if (trimmed_length == 3 && !strncasecmp(trimmed, "yes", trimmed_length)) {
------------------
| Branch (177:9): [True: 157, False: 11.2k]
| Branch (177:32): [True: 66, False: 91]
------------------
178| 66| *result = 1;
179| 66| return IGRAPH_SUCCESS;
180| 66| }
181| |
182| 11.3k| if (trimmed_length == 5 && !strncasecmp(trimmed, "false", trimmed_length)) {
------------------
| Branch (182:9): [True: 10.1k, False: 1.19k]
| Branch (182:32): [True: 10.0k, False: 91]
------------------
183| 10.0k| *result = 0;
184| 10.0k| return IGRAPH_SUCCESS;
185| 10.0k| }
186| |
187| 1.28k| if (trimmed_length == 2 && !strncasecmp(trimmed, "no", trimmed_length)) {
------------------
| Branch (187:9): [True: 410, False: 872]
| Branch (187:32): [True: 205, False: 205]
------------------
188| 205| *result = 0;
189| 205| return IGRAPH_SUCCESS;
190| 205| }
191| |
192| 1.07k| if (trimmed_length > 0) {
------------------
| Branch (192:9): [True: 865, False: 212]
------------------
193| 865| if (isdigit(trimmed[0])) {
------------------
| Branch (193:13): [True: 817, False: 48]
------------------
194| 817| IGRAPH_CHECK(igraph_i_parse_integer(trimmed, trimmed_length, &value));
------------------
| | 656| 817| do { \
| | 657| 817| igraph_error_t igraph_i_ret = (expr); \
| | 658| 817| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 817| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 27, False: 790]
| | | | ------------------
| | ------------------
| | 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| 817| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 790]
| | ------------------
------------------
195| 817| } else {
196| 48| IGRAPH_ERRORF("Cannot parse '%.*s' as Boolean value.", IGRAPH_PARSEERROR,
------------------
| | 464| 48| do { \
| | 465| 48| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 48| igraph_errno, __VA_ARGS__) ; \
| | 467| 48| return igraph_errno; \
| | 468| 48| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
197| 48| (int) trimmed_length, trimmed);
198| 48| }
199| 865| } else {
200| 212| *result = default_value;
201| 212| return IGRAPH_SUCCESS;
202| 212| }
203| |
204| 790| *result = value != 0;
205| 790| return IGRAPH_SUCCESS;
206| 1.07k|}
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.45k, False: 421]
------------------
150| 6.45k| IGRAPH_CHECK(igraph_i_parse_real(trimmed, trimmed_length, result));
------------------
| | 656| 6.45k| do { \
| | 657| 6.45k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.45k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.45k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 18, False: 6.44k]
| | | | ------------------
| | ------------------
| | 659| 18| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 660| 18| } \
| | 661| 6.45k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.44k]
| | ------------------
------------------
151| 6.45k| } else {
152| 421| *result = default_value;
153| 421| }
154| |
155| 6.86k| return IGRAPH_SUCCESS;
156| 6.88k|}
graphml.c:igraph_i_graphml_attribute_data_finish:
797| 408k|static igraph_error_t igraph_i_graphml_attribute_data_finish(struct igraph_i_graphml_parser_state *state) {
798| 408k| const char *key = fromXmlChar(state->data_key);
------------------
| | 76| 408k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
799| 408k| igraph_attribute_elemtype_t type = state->data_type;
800| 408k| igraph_trie_t *trie = NULL;
801| 408k| igraph_vector_ptr_t *ptrvector = NULL;
802| 408k| igraph_i_graphml_attribute_record_t *graphmlrec;
803| 408k| igraph_attribute_record_t *rec;
804| 408k| igraph_int_t recid, id = 0;
805| 408k| igraph_error_t result = IGRAPH_SUCCESS;
806| |
807| 408k| switch (type) {
808| 3.33k| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (808:5): [True: 3.33k, False: 405k]
------------------
809| 3.33k| trie = &state->g_attr_ids;
810| 3.33k| ptrvector = &state->g_attrs;
811| 3.33k| id = 0;
812| 3.33k| break;
813| 50.7k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (813:5): [True: 50.7k, False: 358k]
------------------
814| 50.7k| trie = &state->v_attr_ids;
815| 50.7k| ptrvector = &state->v_attrs;
816| 50.7k| id = state->act_node;
817| 50.7k| break;
818| 354k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (818:5): [True: 354k, False: 54.0k]
------------------
819| 354k| trie = &state->e_attr_ids;
820| 354k| ptrvector = &state->e_attrs;
821| 354k| id = igraph_vector_int_size(&state->edgelist) / 2 - 1; /* hack */
822| 354k| break;
823| 0| default:
------------------
| Branch (823:5): [True: 0, False: 408k]
------------------
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| 408k| }
826| |
827| 408k| if (key == 0) {
------------------
| Branch (827:9): [True: 282, False: 408k]
------------------
828| | /* no key specified, issue a warning */
829| 282| IGRAPH_WARNING("Missing attribute key in a tag, ignoring attribute.");
------------------
| | 797| 282| do { \
| | 798| 282| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 282| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 282]
| | ------------------
------------------
830| 282| goto exit;
831| 282| }
832| |
833| 408k| IGRAPH_CHECK(igraph_trie_check(trie, key, &recid));
------------------
| | 656| 408k| do { \
| | 657| 408k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 408k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 408k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 408k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 408k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 408k]
| | ------------------
------------------
834| 408k| if (recid < 0) {
------------------
| Branch (834:9): [True: 1.55k, False: 407k]
------------------
835| | /* no such attribute key, issue a warning */
836| 1.55k| IGRAPH_WARNINGF(
------------------
| | 777| 1.55k| do { \
| | 778| 1.55k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 1.55k| __VA_ARGS__); \
| | 780| 1.55k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 1.55k]
| | ------------------
------------------
837| 1.55k| "Unknown attribute key '%s' in a tag, ignoring attribute.",
838| 1.55k| key
839| 1.55k| );
840| 1.55k| goto exit;
841| 1.55k| }
842| |
843| 407k| graphmlrec = VECTOR(*ptrvector)[recid];
------------------
| | 60| 407k|#define VECTOR(v) ((v).stor_begin)
------------------
844| 407k| rec = &graphmlrec->record;
845| |
846| 407k| if (id >= igraph_attribute_record_size(rec) && rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (846:9): [True: 406k, False: 733]
| Branch (846:52): [True: 405k, False: 390]
------------------
847| 405k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, id + 1));
------------------
| | 656| 405k| do { \
| | 657| 405k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 405k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 405k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 405k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 405k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 405k]
| | ------------------
------------------
848| 405k| }
849| |
850| 407k| 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| 10.1k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (856:5): [True: 10.1k, False: 396k]
------------------
857| | /* Add null terminator */
858| 10.1k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 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]
| | ------------------
------------------
859| 10.1k| boolvec = rec->value.as_vector_bool;
860| 10.1k| IGRAPH_CHECK(igraph_i_graphml_parse_boolean(
------------------
| | 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: 13, False: 10.1k]
| | | | ------------------
| | ------------------
| | 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| 10.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.1k]
| | ------------------
------------------
861| 10.1k| VECTOR(state->data_char), VECTOR(*boolvec) + id, rec->default_value.boolean
862| 10.1k| ));
863| 10.1k| break;
864| |
865| 10.1k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (865:5): [True: 6.40k, False: 400k]
------------------
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: 14, False: 6.38k]
| | | | ------------------
| | ------------------
| | 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| 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| 390k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (874:5): [True: 390k, False: 16.9k]
------------------
875| | /* Ensure that the vector ends with a null terminator */
876| 390k| strvec = rec->value.as_strvector;
877| 390k| if (igraph_vector_char_size(&state->data_char) > 0) {
------------------
| Branch (877:13): [True: 277k, False: 112k]
------------------
878| 277k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 277k| do { \
| | 657| 277k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 277k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 277k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 277k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 277k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 277k]
| | ------------------
------------------
879| 277k| strvalue = VECTOR(state->data_char);
------------------
| | 60| 277k|#define VECTOR(v) ((v).stor_begin)
------------------
880| 277k| } else {
881| 112k| strvalue = rec->default_value.string;
882| 112k| }
883| 390k| IGRAPH_CHECK(igraph_strvector_set(strvec, id, strvalue ? strvalue : ""));
------------------
| | 656| 390k| do { \
| | 657| 780k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 277k, False: 112k]
| | ------------------
| | 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]
| | ------------------
------------------
884| 390k| break;
885| |
886| 390k| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (886:5): [True: 390, False: 406k]
------------------
887| 390| break;
888| |
889| 0| default:
------------------
| Branch (889:5): [True: 0, False: 407k]
------------------
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| 407k| }
892| |
893| 408k|exit:
894| 408k| igraph_vector_char_clear(&state->data_char);
895| |
896| 408k| return result;
897| 407k|}
graphml.c:igraph_i_graphml_parser_state_finish_parsing:
389| 6.31k|static igraph_error_t igraph_i_graphml_parser_state_finish_parsing(struct igraph_i_graphml_parser_state *state) {
390| 6.31k| igraph_int_t i;
391| 6.31k| const char *idstr = "id";
392| 6.31k| igraph_bool_t already_has_vertex_id = false, already_has_edge_id = false;
393| 6.31k| igraph_attribute_record_list_t vattr, eattr, gattr;
394| 6.31k| igraph_attribute_record_t *idrec;
395| |
396| 6.31k| IGRAPH_ASSERT(state->successful);
------------------
| | 924| 6.31k| do { \
| | 925| 6.31k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.31k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.31k]
| | ------------------
------------------
397| |
398| | /* check that we have found and parsed the graph the user is interested in */
399| 6.31k| IGRAPH_ASSERT(state->index < 0);
------------------
| | 924| 6.31k| do { \
| | 925| 6.31k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.31k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.31k]
| | ------------------
------------------
400| |
401| 6.31k| IGRAPH_CHECK(igraph_attribute_record_list_init(&vattr, 0));
------------------
| | 656| 6.31k| do { \
| | 657| 6.31k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.31k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.31k]
| | ------------------
------------------
402| 6.31k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &vattr);
------------------
| | 603| 6.31k| do { \
| | 604| 6.31k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.31k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.31k| * incorrect destructor function with the pointer */ \
| | 607| 6.31k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.31k]
| | ------------------
| | 608| 6.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.31k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.31k]
| | ------------------
------------------
403| 6.31k| IGRAPH_CHECK(igraph_attribute_record_list_init(&eattr, 0));
------------------
| | 656| 6.31k| do { \
| | 657| 6.31k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.31k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.31k]
| | ------------------
------------------
404| 6.31k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &eattr);
------------------
| | 603| 6.31k| do { \
| | 604| 6.31k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.31k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.31k| * incorrect destructor function with the pointer */ \
| | 607| 6.31k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.31k]
| | ------------------
| | 608| 6.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.31k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.31k]
| | ------------------
------------------
405| 6.31k| IGRAPH_CHECK(igraph_attribute_record_list_init(&gattr, 0));
------------------
| | 656| 6.31k| do { \
| | 657| 6.31k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.31k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.31k]
| | ------------------
------------------
406| 6.31k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &gattr);
------------------
| | 603| 6.31k| do { \
| | 604| 6.31k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.31k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.31k| * incorrect destructor function with the pointer */ \
| | 607| 6.31k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.31k]
| | ------------------
| | 608| 6.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.31k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.31k]
| | ------------------
------------------
407| |
408| | /* Add default attribute values for vertices where needed */
409| 12.9k| for (i = 0; i < igraph_vector_ptr_size(&state->v_attrs); i++) {
------------------
| Branch (409:17): [True: 6.66k, False: 6.31k]
------------------
410| 6.66k| igraph_i_graphml_attribute_record_t *graphmlrec =
411| 6.66k| VECTOR(state->v_attrs)[i];
------------------
| | 60| 6.66k|#define VECTOR(v) ((v).stor_begin)
------------------
412| 6.66k| 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.66k| if (!strcmp(rec->name, idstr)) {
------------------
| Branch (416:13): [True: 3.19k, False: 3.47k]
------------------
417| 3.19k| already_has_vertex_id = 1;
418| 3.19k| }
419| |
420| 6.66k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (420:13): [True: 6.61k, False: 47]
------------------
421| 6.61k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, igraph_trie_size(&state->node_trie)));
------------------
| | 656| 6.61k| do { \
| | 657| 6.61k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.61k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.61k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.61k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.61k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.61k]
| | ------------------
------------------
422| 6.61k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&vattr, rec));
------------------
| | 656| 6.61k| do { \
| | 657| 6.61k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.61k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.61k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.61k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.61k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.61k]
| | ------------------
------------------
423| 6.61k| graphmlrec->record_disowned = true;
424| 6.61k| }
425| 6.66k| }
426| |
427| | /* Add vertex ID attribute if needed */
428| 6.31k| if (!already_has_vertex_id) {
------------------
| Branch (428:9): [True: 3.12k, False: 3.19k]
------------------
429| 3.12k| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(&vattr, &idrec));
------------------
| | 656| 3.12k| do { \
| | 657| 3.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.12k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.12k]
| | ------------------
------------------
430| 3.12k| IGRAPH_CHECK(igraph_attribute_record_set_name(idrec, idstr));
------------------
| | 656| 3.12k| do { \
| | 657| 3.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.12k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.12k]
| | ------------------
------------------
431| 3.12k| IGRAPH_CHECK(igraph_attribute_record_set_type(idrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.12k| do { \
| | 657| 3.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.12k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.12k]
| | ------------------
------------------
432| 3.12k| IGRAPH_CHECK(igraph_strvector_update(idrec->value.as_strvector, igraph_i_trie_borrow_keys(&state->node_trie)));
------------------
| | 656| 3.12k| do { \
| | 657| 3.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.12k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.12k]
| | ------------------
------------------
433| 3.19k| } else {
434| 3.19k| IGRAPH_WARNING("Could not add vertex ids, there is already an 'id' vertex attribute.");
------------------
| | 797| 3.19k| do { \
| | 798| 3.19k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 3.19k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 3.19k]
| | ------------------
------------------
435| 3.19k| }
436| |
437| | /* Add default attribute values for edges where needed */
438| 10.9k| for (i = 0; i < igraph_vector_ptr_size(&state->e_attrs); i++) {
------------------
| Branch (438:17): [True: 4.63k, False: 6.31k]
------------------
439| 4.63k| igraph_i_graphml_attribute_record_t *graphmlrec =
440| 4.63k| VECTOR(state->e_attrs)[i];
------------------
| | 60| 4.63k|#define VECTOR(v) ((v).stor_begin)
------------------
441| 4.63k| igraph_attribute_record_t *rec = &graphmlrec->record;
442| |
443| 4.63k| if (!strcmp(rec->name, idstr)) {
------------------
| Branch (443:13): [True: 894, False: 3.74k]
------------------
444| 894| already_has_edge_id = 1;
445| 894| }
446| |
447| 4.63k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (447:13): [True: 4.46k, False: 168]
------------------
448| 4.46k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, igraph_vector_int_size(&state->edgelist) / 2));
------------------
| | 656| 4.46k| do { \
| | 657| 4.46k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.46k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.46k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.46k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.46k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.46k]
| | ------------------
------------------
449| 4.46k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&eattr, rec));
------------------
| | 656| 4.46k| do { \
| | 657| 4.46k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.46k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.46k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.46k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.46k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.46k]
| | ------------------
------------------
450| 4.46k| graphmlrec->record_disowned = true;
451| 4.46k| }
452| 4.63k| }
453| |
454| | /* Add edge ID attribute if needed */
455| 6.31k| if (igraph_strvector_size(&state->edgeids) != 0) {
------------------
| Branch (455:9): [True: 895, False: 5.42k]
------------------
456| 895| if (!already_has_edge_id) {
------------------
| Branch (456:13): [True: 894, False: 1]
------------------
457| 894| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(&eattr, &idrec));
------------------
| | 656| 894| do { \
| | 657| 894| igraph_error_t igraph_i_ret = (expr); \
| | 658| 894| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 894| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 894]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 894| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 894]
| | ------------------
------------------
458| 894| IGRAPH_CHECK(igraph_attribute_record_set_name(idrec, idstr));
------------------
| | 656| 894| do { \
| | 657| 894| igraph_error_t igraph_i_ret = (expr); \
| | 658| 894| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 894| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 894]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 894| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 894]
| | ------------------
------------------
459| 894| IGRAPH_CHECK(igraph_attribute_record_set_type(idrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 894| do { \
| | 657| 894| igraph_error_t igraph_i_ret = (expr); \
| | 658| 894| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 894| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 894]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 894| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 894]
| | ------------------
------------------
460| 894| IGRAPH_CHECK(igraph_strvector_update(idrec->value.as_strvector, &state->edgeids));
------------------
| | 656| 894| do { \
| | 657| 894| igraph_error_t igraph_i_ret = (expr); \
| | 658| 894| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 894| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 894]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 894| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 894]
| | ------------------
------------------
461| 894| IGRAPH_CHECK(igraph_attribute_record_resize(idrec, igraph_vector_int_size(&state->edgelist) / 2));
------------------
| | 656| 894| do { \
| | 657| 894| igraph_error_t igraph_i_ret = (expr); \
| | 658| 894| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 894| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 894]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 894| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 894]
| | ------------------
------------------
462| 894| } 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| 895| }
466| |
467| | /* Add default graph attribute values where needed */
468| 7.96k| for (i = 0; i < igraph_vector_ptr_size(&state->g_attrs); i++) {
------------------
| Branch (468:17): [True: 1.64k, False: 6.31k]
------------------
469| 1.64k| igraph_i_graphml_attribute_record_t *graphmlrec =
470| 1.64k| VECTOR(state->g_attrs)[i];
------------------
| | 60| 1.64k|#define VECTOR(v) ((v).stor_begin)
------------------
471| 1.64k| igraph_attribute_record_t *rec = &graphmlrec->record;
472| |
473| 1.64k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (473:13): [True: 1.58k, False: 55]
------------------
474| 1.58k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, 1));
------------------
| | 656| 1.58k| do { \
| | 657| 1.58k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.58k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.58k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.58k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.58k]
| | ------------------
------------------
475| 1.58k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&gattr, rec));
------------------
| | 656| 1.58k| do { \
| | 657| 1.58k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.58k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.58k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.58k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.58k]
| | ------------------
------------------
476| 1.58k| graphmlrec->record_disowned = true;
477| 1.58k| }
478| 1.64k| }
479| |
480| 6.31k| IGRAPH_CHECK(igraph_empty_attrs(state->g, 0, state->edges_directed, &gattr));
------------------
| | 656| 6.31k| do { \
| | 657| 6.31k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.31k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.31k]
| | ------------------
------------------
481| 6.31k| IGRAPH_FINALLY(igraph_destroy, state->g); /* because the next two lines may fail as well */
------------------
| | 603| 6.31k| do { \
| | 604| 6.31k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.31k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.31k| * incorrect destructor function with the pointer */ \
| | 607| 6.31k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.31k]
| | ------------------
| | 608| 6.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.31k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.31k]
| | ------------------
------------------
482| 6.31k| IGRAPH_CHECK(igraph_add_vertices(state->g, igraph_trie_size(&state->node_trie), &vattr));
------------------
| | 656| 6.31k| do { \
| | 657| 6.31k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.31k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.31k]
| | ------------------
------------------
483| 6.31k| IGRAPH_CHECK(igraph_add_edges(state->g, &state->edgelist, &eattr));
------------------
| | 656| 6.31k| do { \
| | 657| 6.31k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.31k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.31k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.31k]
| | ------------------
------------------
484| 6.31k| IGRAPH_FINALLY_CLEAN(1); /* graph construction completed successfully */
485| |
486| 6.31k| igraph_attribute_record_list_destroy(&vattr);
487| 6.31k| igraph_attribute_record_list_destroy(&eattr);
488| 6.31k| igraph_attribute_record_list_destroy(&gattr);
489| 6.31k| IGRAPH_FINALLY_CLEAN(3);
490| |
491| 6.31k| return IGRAPH_SUCCESS;
492| 6.31k|}
graphml.c:igraph_i_xml_escape:
1371| 804k|static igraph_error_t igraph_i_xml_escape(const char *src, char **dest, const char *what) {
1372| 804k| igraph_int_t destlen = 0;
1373| 804k| const char *s;
1374| 804k| char *d;
1375| 804k| unsigned char ch;
1376| |
1377| 252M| for (s = src; *s; s++, destlen++) {
------------------
| Branch (1377:19): [True: 251M, False: 804k]
------------------
1378| 251M| ch = (unsigned char)(*s);
1379| 251M| if (ch == '&') {
------------------
| Branch (1379:13): [True: 1.57k, False: 251M]
------------------
1380| 1.57k| destlen += 4;
1381| 251M| } else if (ch == '<') {
------------------
| Branch (1381:20): [True: 108k, False: 251M]
------------------
1382| 108k| destlen += 3;
1383| 251M| } else if (ch == '>') {
------------------
| Branch (1383:20): [True: 24.6M, False: 226M]
------------------
1384| 24.6M| destlen += 3;
1385| 226M| } else if (ch == '"') {
------------------
| Branch (1385:20): [True: 14.1M, False: 212M]
------------------
1386| 14.1M| destlen += 5;
1387| 212M| } else if (ch == '\'') {
------------------
| Branch (1387:20): [True: 112M, False: 100M]
------------------
1388| 112M| destlen += 5;
1389| 112M| } else if (IS_FORBIDDEN_CONTROL_CHAR(ch)) {
------------------
| | 1363| 100M|#define IS_FORBIDDEN_CONTROL_CHAR(x) ((x) < ' ' && (x) != '\t' && (x) != '\r' && (x) != '\n')
| | ------------------
| | | Branch (1363:39): [True: 12.3M, False: 88.2M]
| | | Branch (1363:52): [True: 12.1M, False: 181k]
| | | Branch (1363:67): [True: 12.1M, False: 708]
| | | Branch (1363:82): [True: 0, False: 12.1M]
| | ------------------
------------------
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| 251M| }
1394| 804k| *dest = IGRAPH_CALLOC(destlen + 1, char);
------------------
| | 33| 804k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.60M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 804k, False: 0]
| | | | | Branch (31:24): [True: 804k, False: 0]
| | | | | Branch (31:66): [True: 804k, False: 0]
| | | | ------------------
| | ------------------
------------------
1395| 804k| IGRAPH_CHECK_OOM(dest, "Insufficient memory to write GraphML file.");
------------------
| | 709| 804k| do { \
| | 710| 804k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 804k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 804k]
| | | | ------------------
| | ------------------
| | 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| 804k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 804k]
| | ------------------
------------------
1396| 252M| for (s = src, d = *dest; *s; s++, d++) {
------------------
| Branch (1396:30): [True: 251M, False: 804k]
------------------
1397| 251M| ch = (unsigned char)(*s);
1398| 251M| switch (ch) {
1399| 1.57k| case '&':
------------------
| Branch (1399:9): [True: 1.57k, False: 251M]
------------------
1400| 1.57k| strcpy(d, "&"); d += 4; break;
1401| 108k| case '<':
------------------
| Branch (1401:9): [True: 108k, False: 251M]
------------------
1402| 108k| strcpy(d, "<"); d += 3; break;
1403| 24.6M| case '>':
------------------
| Branch (1403:9): [True: 24.6M, False: 226M]
------------------
1404| 24.6M| strcpy(d, ">"); d += 3; break;
1405| 14.1M| case '"':
------------------
| Branch (1405:9): [True: 14.1M, False: 237M]
------------------
1406| 14.1M| strcpy(d, """); d += 5; break;
1407| 112M| case '\'':
------------------
| Branch (1407:9): [True: 112M, False: 139M]
------------------
1408| 112M| strcpy(d, "'"); d += 5; break;
1409| 100M| default:
------------------
| Branch (1409:9): [True: 100M, False: 150M]
------------------
1410| 100M| *d = ch;
1411| 251M| }
1412| 251M| }
1413| 804k| *d = 0;
1414| 804k| return IGRAPH_SUCCESS;
1415| 804k|}
igraph_write_graph_leda:
66| 3.17k| const char *edge_attr_name) {
67| 3.17k| igraph_int_t no_of_nodes = igraph_vcount(graph);
68| 3.17k| igraph_int_t no_of_edges = igraph_ecount(graph);
69| 3.17k| igraph_eit_t it;
70| 3.17k| igraph_int_t i = 0;
71| 3.17k| igraph_attribute_type_t vertex_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
72| 3.17k| igraph_attribute_type_t edge_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
73| 3.17k| igraph_int_t from, to, rev;
74| |
75| 3.17k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM), &it));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
76| 3.17k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
77| |
78| | /* Check if we have the vertex attribute */
79| 3.17k| if (vertex_attr_name &&
------------------
| Branch (79:9): [True: 3.17k, False: 0]
------------------
80| 3.17k| !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vertex_attr_name)) {
------------------
| Branch (80:9): [True: 2.71k, False: 463]
------------------
81| 2.71k| IGRAPH_WARNINGF("The vertex attribute '%s' does not exist. No vertex values will be written.",
------------------
| | 777| 2.71k| do { \
| | 778| 2.71k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.71k| __VA_ARGS__); \
| | 780| 2.71k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.71k]
| | ------------------
------------------
82| 2.71k| vertex_attr_name);
83| 2.71k| vertex_attr_name = NULL;
84| 2.71k| }
85| 3.17k| if (vertex_attr_name) {
------------------
| Branch (85:9): [True: 463, False: 2.71k]
------------------
86| 463| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &vertex_attr_type,
------------------
| | 656| 463| do { \
| | 657| 463| igraph_error_t igraph_i_ret = (expr); \
| | 658| 463| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 463| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 463]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 463| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 463]
| | ------------------
------------------
87| 463| IGRAPH_ATTRIBUTE_VERTEX, vertex_attr_name));
88| 463| if (vertex_attr_type != IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| Branch (88:13): [True: 446, False: 17]
------------------
89| 446| vertex_attr_type != IGRAPH_ATTRIBUTE_STRING &&
------------------
| Branch (89:13): [True: 27, False: 419]
------------------
90| 27| vertex_attr_type != IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (90:13): [True: 0, False: 27]
------------------
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| 463| }
97| |
98| | /* Check if we have the edge attribute */
99| 3.17k| if (edge_attr_name &&
------------------
| Branch (99:9): [True: 3.17k, False: 0]
------------------
100| 3.17k| !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, edge_attr_name)) {
------------------
| Branch (100:9): [True: 2.94k, False: 230]
------------------
101| 2.94k| IGRAPH_WARNINGF("The edge attribute '%s' does not exist. No edge values will be written.",
------------------
| | 777| 2.94k| do { \
| | 778| 2.94k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.94k| __VA_ARGS__); \
| | 780| 2.94k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.94k]
| | ------------------
------------------
102| 2.94k| edge_attr_name);
103| 2.94k| edge_attr_name = NULL;
104| 2.94k| }
105| 3.17k| if (edge_attr_name) {
------------------
| Branch (105:9): [True: 230, False: 2.94k]
------------------
106| 230| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &edge_attr_type,
------------------
| | 656| 230| do { \
| | 657| 230| igraph_error_t igraph_i_ret = (expr); \
| | 658| 230| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 230| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 230]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 230| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 230]
| | ------------------
------------------
107| 230| IGRAPH_ATTRIBUTE_EDGE, edge_attr_name));
108| 230| if (edge_attr_type != IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| Branch (108:13): [True: 50, False: 180]
------------------
109| 50| edge_attr_type != IGRAPH_ATTRIBUTE_STRING &&
------------------
| Branch (109:13): [True: 1, False: 49]
------------------
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| 230| }
117| |
118| | /* Start writing header */
119| 3.17k| CHECK(fprintf(outstream, "LEDA.GRAPH\n"));
------------------
| | 33| 3.17k| do { \
| | 34| 3.17k| int ret=(cmd); \
| | 35| 3.17k| 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.17k]
| | ------------------
| | 36| 3.17k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.17k]
| | ------------------
------------------
120| |
121| 3.17k| switch (vertex_attr_type) {
122| 17| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (122:5): [True: 17, False: 3.16k]
------------------
123| 17| CHECK(fprintf(outstream, "double\n"));
------------------
| | 33| 17| do { \
| | 34| 17| int ret=(cmd); \
| | 35| 17| 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: 17]
| | ------------------
| | 36| 17| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 17]
| | ------------------
------------------
124| 17| break;
125| 419| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (125:5): [True: 419, False: 2.76k]
------------------
126| 419| CHECK(fprintf(outstream, "string\n"));
------------------
| | 33| 419| do { \
| | 34| 419| int ret=(cmd); \
| | 35| 419| 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: 419]
| | ------------------
| | 36| 419| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 419]
| | ------------------
------------------
127| 419| break;
128| 419| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (128:5): [True: 27, False: 3.15k]
------------------
129| 27| CHECK(fprintf(outstream, "bool\n"));
------------------
| | 33| 27| do { \
| | 34| 27| int ret=(cmd); \
| | 35| 27| 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: 27]
| | ------------------
| | 36| 27| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 27]
| | ------------------
------------------
130| 27| break;
131| 2.71k| default:
------------------
| Branch (131:5): [True: 2.71k, False: 463]
------------------
132| 2.71k| CHECK(fprintf(outstream, "void\n"));
------------------
| | 33| 2.71k| do { \
| | 34| 2.71k| int ret=(cmd); \
| | 35| 2.71k| 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.71k]
| | ------------------
| | 36| 2.71k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 2.71k]
| | ------------------
------------------
133| 3.17k| }
134| |
135| 3.17k| switch (edge_attr_type) {
136| 180| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (136:5): [True: 180, False: 2.99k]
------------------
137| 180| CHECK(fprintf(outstream, "double\n"));
------------------
| | 33| 180| do { \
| | 34| 180| int ret=(cmd); \
| | 35| 180| 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: 180]
| | ------------------
| | 36| 180| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 180]
| | ------------------
------------------
138| 180| break;
139| 180| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (139:5): [True: 49, False: 3.13k]
------------------
140| 49| CHECK(fprintf(outstream, "string\n"));
------------------
| | 33| 49| do { \
| | 34| 49| int ret=(cmd); \
| | 35| 49| 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: 49]
| | ------------------
| | 36| 49| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 49]
| | ------------------
------------------
141| 49| break;
142| 49| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (142:5): [True: 1, False: 3.17k]
------------------
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| 2.94k| default:
------------------
| Branch (145:5): [True: 2.94k, False: 230]
------------------
146| 2.94k| CHECK(fprintf(outstream, "void\n"));
------------------
| | 33| 2.94k| do { \
| | 34| 2.94k| int ret=(cmd); \
| | 35| 2.94k| 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.94k]
| | ------------------
| | 36| 2.94k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 2.94k]
| | ------------------
------------------
147| 3.17k| }
148| |
149| 3.17k| CHECK(fprintf(outstream, "%d\n", (igraph_is_directed(graph) ? -1 : -2)));
------------------
| | 33| 3.17k| do { \
| | 34| 6.35k| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 133, False: 3.04k]
| | ------------------
| | 35| 3.17k| 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.17k]
| | ------------------
| | 36| 3.17k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.17k]
| | ------------------
------------------
150| |
151| | /* Start writing vertices */
152| 3.17k| CHECK(fprintf(outstream, "# Vertices\n"));
------------------
| | 33| 3.17k| do { \
| | 34| 3.17k| int ret=(cmd); \
| | 35| 3.17k| 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.17k]
| | ------------------
| | 36| 3.17k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.17k]
| | ------------------
------------------
153| 3.17k| CHECK(fprintf(outstream, "%" IGRAPH_PRId "\n", no_of_nodes));
------------------
| | 33| 3.17k| do { \
| | 34| 3.17k| int ret=(cmd); \
| | 35| 3.17k| 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.17k]
| | ------------------
| | 36| 3.17k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.17k]
| | ------------------
------------------
154| |
155| 3.17k| if (vertex_attr_type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (155:9): [True: 17, False: 3.16k]
------------------
156| | /* Vertices with numeric attributes */
157| 17| igraph_vector_t values;
158| |
159| 17| IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 104| 17| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 17| do { \
| | | | 657| 17| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 17| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 17| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 17]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 17]
| | | | ------------------
| | ------------------
| | 105| 17| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 17| do { \
| | | | 604| 17| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 17| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 17| * incorrect destructor function with the pointer */ \
| | | | 607| 17| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 17]
| | | | ------------------
| | | | 608| 17| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 17| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 17]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 17]
| | ------------------
------------------
160| 17| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 656| 17| do { \
| | 657| 17| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17]
| | ------------------
------------------
161| 17| graph, vertex_attr_name, igraph_vss_all(), &values));
162| |
163| 308| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (163:21): [True: 291, False: 17]
------------------
164| 291| CHECK(fprintf(outstream, "|{"));
------------------
| | 33| 291| do { \
| | 34| 291| int ret=(cmd); \
| | 35| 291| 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: 291]
| | ------------------
| | 36| 291| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 291]
| | ------------------
------------------
165| 291| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(values)[i]));
------------------
| | 33| 291| do { \
| | 34| 291| int ret=(cmd); \
| | 35| 291| 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: 291]
| | ------------------
| | 36| 291| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 291]
| | ------------------
------------------
166| 291| CHECK(fprintf(outstream, "}|\n"));
------------------
| | 33| 291| do { \
| | 34| 291| int ret=(cmd); \
| | 35| 291| 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: 291]
| | ------------------
| | 36| 291| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 291]
| | ------------------
------------------
167| 291| }
168| |
169| 17| igraph_vector_destroy(&values);
170| 17| IGRAPH_FINALLY_CLEAN(1);
171| 3.16k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (171:16): [True: 419, False: 2.74k]
------------------
172| | /* Vertices with string attributes */
173| 419| igraph_strvector_t values;
174| |
175| 419| IGRAPH_CHECK(igraph_strvector_init(&values, no_of_nodes));
------------------
| | 656| 419| do { \
| | 657| 419| igraph_error_t igraph_i_ret = (expr); \
| | 658| 419| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 419| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 419]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 419| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 419]
| | ------------------
------------------
176| 419| IGRAPH_FINALLY(igraph_strvector_destroy, &values);
------------------
| | 603| 419| do { \
| | 604| 419| /* the following branch makes the compiler check the compatibility of \
| | 605| 419| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 419| * incorrect destructor function with the pointer */ \
| | 607| 419| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 419]
| | ------------------
| | 608| 419| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 419| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 419]
| | ------------------
------------------
177| |
178| 419| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 419| do { \
| | 657| 419| igraph_error_t igraph_i_ret = (expr); \
| | 658| 419| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 419| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 419]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 419| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 419]
| | ------------------
------------------
179| 419| graph, vertex_attr_name, igraph_vss_all(), &values));
180| |
181| 7.25k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (181:21): [True: 6.87k, False: 375]
------------------
182| 6.87k| const char *str = igraph_strvector_get(&values, i);
183| 6.87k| if (strchr(str, '\n') != 0) {
------------------
| Branch (183:17): [True: 44, False: 6.83k]
------------------
184| 44| IGRAPH_ERROR("Vertex attribute values cannot contain newline characters.",
------------------
| | 426| 44| do { \
| | 427| 44| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 44| return igraph_errno ; \
| | 429| 44| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
185| 44| IGRAPH_EINVAL);
186| 44| }
187| 6.83k| CHECK(fprintf(outstream, "|{%s}|\n", str));
------------------
| | 33| 6.83k| do { \
| | 34| 6.83k| int ret=(cmd); \
| | 35| 6.83k| 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.83k]
| | ------------------
| | 36| 6.83k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 6.83k]
| | ------------------
------------------
188| 6.83k| }
189| |
190| 375| igraph_strvector_destroy(&values);
191| 375| IGRAPH_FINALLY_CLEAN(1);
192| 2.74k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (192:16): [True: 27, False: 2.71k]
------------------
193| | /* Vertices with boolean attributes */
194| 27| igraph_vector_bool_t values;
195| |
196| 27| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 109| 27| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 27| do { \
| | | | 657| 27| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 27| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 27| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 27]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 27]
| | | | ------------------
| | ------------------
| | 110| 27| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 27| do { \
| | | | 604| 27| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 27| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 27| * incorrect destructor function with the pointer */ \
| | | | 607| 27| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 27]
| | | | ------------------
| | | | 608| 27| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 27| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 27]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 27]
| | ------------------
------------------
197| 27| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(
------------------
| | 656| 27| do { \
| | 657| 27| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27]
| | ------------------
------------------
198| 27| graph, vertex_attr_name, igraph_vss_all(), &values));
199| |
200| 220| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (200:21): [True: 193, False: 27]
------------------
201| 193| CHECK(fprintf(outstream, "|{%s|}\n", VECTOR(values)[i] ? "true" : "false"));
------------------
| | 33| 193| do { \
| | 34| 386| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 0, False: 193]
| | ------------------
| | 35| 193| 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: 193]
| | ------------------
| | 36| 193| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 193]
| | ------------------
------------------
202| 193| }
203| |
204| 27| igraph_vector_bool_destroy(&values);
205| 27| IGRAPH_FINALLY_CLEAN(1);
206| 2.71k| } else {
207| | /* Vertices with no attributes */
208| 27.3k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (208:21): [True: 24.6k, False: 2.71k]
------------------
209| 24.6k| CHECK(fprintf(outstream, "|{}|\n"));
------------------
| | 33| 24.6k| do { \
| | 34| 24.6k| int ret=(cmd); \
| | 35| 24.6k| 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: 24.6k]
| | ------------------
| | 36| 24.6k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 24.6k]
| | ------------------
------------------
210| 24.6k| }
211| 2.71k| }
212| |
213| 3.13k| CHECK(fprintf(outstream, "# Edges\n"));
------------------
| | 33| 3.13k| do { \
| | 34| 3.13k| int ret=(cmd); \
| | 35| 3.13k| 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.13k]
| | ------------------
| | 36| 3.13k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.13k]
| | ------------------
------------------
214| 3.13k| CHECK(fprintf(outstream, "%" IGRAPH_PRId "\n", no_of_edges));
------------------
| | 33| 3.13k| do { \
| | 34| 3.13k| int ret=(cmd); \
| | 35| 3.13k| 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.13k]
| | ------------------
| | 36| 3.13k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.13k]
| | ------------------
------------------
215| |
216| 3.13k| if (edge_attr_type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (216:9): [True: 178, False: 2.95k]
------------------
217| | /* Edges with numeric attributes */
218| 178| igraph_vector_t values;
219| 178| IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 104| 178| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 178| do { \
| | | | 657| 178| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 178| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 178| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 178]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 178| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 178]
| | | | ------------------
| | ------------------
| | 105| 178| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 178| do { \
| | | | 604| 178| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 178| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 178| * incorrect destructor function with the pointer */ \
| | | | 607| 178| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 178]
| | | | ------------------
| | | | 608| 178| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 178| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 178]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 178]
| | ------------------
------------------
220| 178| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 178| do { \
| | 657| 178| igraph_error_t igraph_i_ret = (expr); \
| | 658| 178| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 178| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 178]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 178| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 178]
| | ------------------
------------------
221| 178| graph, edge_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
222| 91.1k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 91.1k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (222:16): [True: 90.9k, False: 178]
------------------
223| 90.9k| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 90.9k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 90.9k]
| | ------------------
| | 406| 90.9k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 90.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
224| 90.9k| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 90.9k| do { \
| | 657| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.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| 90.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 90.9k]
| | ------------------
------------------
225| 90.9k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 90.9k| do { \
| | 657| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.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| 90.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 90.9k]
| | ------------------
------------------
226| 90.9k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 90.9k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 90.9k]
| | ------------------
| | 406| 90.9k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 90.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (226:17): [True: 3.08k, False: 87.8k]
------------------
227| 3.08k| rev = -1;
228| 3.08k| }
229| 90.9k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{",
------------------
| | 33| 90.9k| do { \
| | 34| 90.9k| int ret=(cmd); \
| | 35| 90.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: 90.9k]
| | ------------------
| | 36| 90.9k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 90.9k]
| | ------------------
------------------
230| 90.9k| from + 1, to + 1,
231| 90.9k| rev + 1));
232| 90.9k| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(values)[eid]));
------------------
| | 33| 90.9k| do { \
| | 34| 90.9k| int ret=(cmd); \
| | 35| 90.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: 90.9k]
| | ------------------
| | 36| 90.9k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 90.9k]
| | ------------------
------------------
233| 90.9k| CHECK(fprintf(outstream, "}|\n"));
------------------
| | 33| 90.9k| do { \
| | 34| 90.9k| int ret=(cmd); \
| | 35| 90.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: 90.9k]
| | ------------------
| | 36| 90.9k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 90.9k]
| | ------------------
------------------
234| 90.9k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 90.9k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
235| 90.9k| }
236| 178| igraph_vector_destroy(&values);
237| 178| IGRAPH_FINALLY_CLEAN(1);
238| 2.95k| } else if (edge_attr_type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (238:16): [True: 49, False: 2.90k]
------------------
239| | /* Edges with string attributes */
240| 49| igraph_strvector_t values;
241| 49| IGRAPH_CHECK(igraph_strvector_init(&values, no_of_nodes));
------------------
| | 656| 49| do { \
| | 657| 49| igraph_error_t igraph_i_ret = (expr); \
| | 658| 49| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 49| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 49| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 49]
| | ------------------
------------------
242| 49| IGRAPH_FINALLY(igraph_strvector_destroy, &values);
------------------
| | 603| 49| do { \
| | 604| 49| /* the following branch makes the compiler check the compatibility of \
| | 605| 49| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 49| * incorrect destructor function with the pointer */ \
| | 607| 49| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 49]
| | ------------------
| | 608| 49| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 49| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 49]
| | ------------------
------------------
243| 49| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(
------------------
| | 656| 49| do { \
| | 657| 49| igraph_error_t igraph_i_ret = (expr); \
| | 658| 49| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 49| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 49| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 49]
| | ------------------
------------------
244| 49| graph, edge_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
245| 45.1k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 45.1k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (245:16): [True: 45.1k, False: 48]
------------------
246| 45.1k| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 45.1k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 45.1k]
| | ------------------
| | 406| 45.1k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 45.1k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
247| 45.1k| const char *str = igraph_strvector_get(&values, eid);
248| 45.1k| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 45.1k| do { \
| | 657| 45.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 45.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 45.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 45.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| 45.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 45.1k]
| | ------------------
------------------
249| 45.1k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 45.1k| do { \
| | 657| 45.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 45.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 45.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 45.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| 45.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 45.1k]
| | ------------------
------------------
250| 45.1k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 45.1k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 45.1k]
| | ------------------
| | 406| 45.1k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 45.1k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (250:17): [True: 642, False: 44.4k]
------------------
251| 642| rev = -1;
252| 642| }
253| 45.1k| if (strchr(str, '\n') != 0) {
------------------
| Branch (253:17): [True: 1, False: 45.1k]
------------------
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| 45.1k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{%s}|\n",
------------------
| | 33| 45.1k| do { \
| | 34| 45.1k| int ret=(cmd); \
| | 35| 45.1k| 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: 45.1k]
| | ------------------
| | 36| 45.1k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 45.1k]
| | ------------------
------------------
258| 45.1k| from + 1, to + 1,
259| 45.1k| rev + 1, str));
260| 45.1k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 45.1k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
261| 45.1k| }
262| 48| igraph_strvector_destroy(&values);
263| 48| IGRAPH_FINALLY_CLEAN(1);
264| 2.90k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (264:16): [True: 26, False: 2.88k]
------------------
265| | /* Edges with boolean attributes */
266| 26| igraph_vector_bool_t values;
267| |
268| 26| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&values, no_of_edges);
------------------
| | 109| 26| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 26| do { \
| | | | 657| 26| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 26| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 26| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 26]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 26]
| | | | ------------------
| | ------------------
| | 110| 26| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 26| do { \
| | | | 604| 26| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 26| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 26| * incorrect destructor function with the pointer */ \
| | | | 607| 26| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 26]
| | | | ------------------
| | | | 608| 26| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 26| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 26]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 26]
| | ------------------
------------------
269| 26| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(
------------------
| | 656| 26| do { \
| | 657| 26| igraph_error_t igraph_i_ret = (expr); \
| | 658| 26| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 26| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 9, False: 17]
| | | | ------------------
| | ------------------
| | 659| 9| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 9| do { \
| | | | 427| 9| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 9| return igraph_errno ; \
| | | | 429| 9| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 9| } \
| | 661| 26| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17]
| | ------------------
------------------
270| 26| graph, vertex_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
271| |
272| 168| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 168|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (272:16): [True: 151, False: 17]
------------------
273| 151| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 151| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 151]
| | ------------------
| | 406| 151| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 151|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
274| 151| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 151| do { \
| | 657| 151| igraph_error_t igraph_i_ret = (expr); \
| | 658| 151| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 151| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 151]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 151| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 151]
| | ------------------
------------------
275| 151| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 151| do { \
| | 657| 151| igraph_error_t igraph_i_ret = (expr); \
| | 658| 151| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 151| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 151]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 151| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 151]
| | ------------------
------------------
276| 151| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 151| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 151]
| | ------------------
| | 406| 151| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 151|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (276:17): [True: 77, False: 74]
------------------
277| 77| rev = -1;
278| 77| }
279| 151| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{%s}|\n",
------------------
| | 33| 151| do { \
| | 34| 302| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 0, False: 151]
| | ------------------
| | 35| 151| 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: 151]
| | ------------------
| | 36| 151| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 151]
| | ------------------
------------------
280| 151| from + 1, to + 1,
281| 151| rev + 1,
282| 151| VECTOR(values)[eid] ? "true" : "false"));
283| 151| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 151|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
284| 151| }
285| |
286| 17| igraph_vector_bool_destroy(&values);
287| 17| IGRAPH_FINALLY_CLEAN(1);
288| 2.88k| } else {
289| | /* Edges with no attributes */
290| 218k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 218k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (290:16): [True: 215k, False: 2.88k]
------------------
291| 215k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 215k| do { \
| | 657| 430k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 0, False: 215k]
| | ------------------
| | 658| 215k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 215k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 215k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 215k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 215k]
| | ------------------
------------------
292| 215k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 215k| do { \
| | 657| 215k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 215k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 215k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 215k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 215k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 215k]
| | ------------------
------------------
293| 215k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 215k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 215k]
| | ------------------
| | 406| 215k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 215k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (293:17): [True: 16.6k, False: 198k]
------------------
294| 16.6k| rev = -1;
295| 16.6k| }
296| 215k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{}|\n",
------------------
| | 33| 215k| do { \
| | 34| 215k| int ret=(cmd); \
| | 35| 215k| 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: 215k]
| | ------------------
| | 36| 215k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 215k]
| | ------------------
------------------
297| 215k| from + 1, to + 1,
298| 215k| rev + 1));
299| 215k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 215k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
300| 215k| }
301| 2.88k| }
302| |
303| 3.12k| igraph_eit_destroy(&it);
304| 3.12k| IGRAPH_FINALLY_CLEAN(1);
305| |
306| 3.12k| return IGRAPH_SUCCESS;
307| 3.13k|}
igraph_read_graph_lgl:
107| 3.02k| igraph_bool_t directed) {
108| |
109| 3.02k| igraph_vector_int_t edges = IGRAPH_VECTOR_NULL;
------------------
| | 99| 3.02k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
------------------
110| 3.02k| igraph_vector_t ws = IGRAPH_VECTOR_NULL;
------------------
| | 99| 3.02k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
------------------
111| 3.02k| igraph_trie_t trie = IGRAPH_TRIE_NULL;
------------------
| | 52| 3.02k| { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 60| 3.02k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 44| 3.02k|#define IGRAPH_VECTOR_PTR_NULL { 0,0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 99| 3.02k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
| | ------------------
| | 53| 3.02k| 0, 0, IGRAPH_STRVECTOR_NULL }
| | ------------------
| | | | 60| 3.02k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
------------------
112| 3.02k| igraph_attribute_record_list_t name, weight;
113| 3.02k| igraph_attribute_record_list_t *pname = NULL, *pweight = NULL;
114| 3.02k| igraph_attribute_record_t *namerec, *weightrec;
115| 3.02k| const char *namestr = "name", *weightstr = "weight";
116| 3.02k| igraph_i_lgl_parsedata_t context;
117| |
118| 3.02k| IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);
------------------
| | 104| 3.02k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.02k| do { \
| | | | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.02k]
| | | | ------------------
| | ------------------
| | 105| 3.02k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.02k| do { \
| | | | 604| 3.02k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.02k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.02k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.02k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.02k]
| | | | ------------------
| | | | 608| 3.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.02k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.02k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.02k]
| | ------------------
------------------
119| 3.02k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0);
------------------
| | 119| 3.02k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.02k| do { \
| | | | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.02k]
| | | | ------------------
| | ------------------
| | 120| 3.02k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.02k| do { \
| | | | 604| 3.02k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.02k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.02k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.02k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.02k]
| | | | ------------------
| | | | 608| 3.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.02k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.02k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.02k]
| | ------------------
------------------
120| 3.02k| IGRAPH_TRIE_INIT_FINALLY(&trie, names);
------------------
| | 55| 3.02k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.02k| do { \
| | | | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.02k]
| | | | ------------------
| | ------------------
| | 56| 3.02k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.02k| do { \
| | | | 604| 3.02k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.02k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.02k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.02k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.02k]
| | | | ------------------
| | | | 608| 3.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.02k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.02k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.02k]
| | ------------------
------------------
121| |
122| 3.02k| context.has_weights = false;
123| 3.02k| context.vector = &edges;
124| 3.02k| context.weights = &ws;
125| 3.02k| context.trie = ≜
126| 3.02k| context.errmsg[0] = '\0';
127| 3.02k| context.igraph_errno = IGRAPH_SUCCESS;
128| |
129| 3.02k| igraph_lgl_yylex_init_extra(&context, &context.scanner);
130| 3.02k| IGRAPH_FINALLY(igraph_lgl_yylex_destroy_wrapper, context.scanner);
------------------
| | 603| 3.02k| do { \
| | 604| 3.02k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.02k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.02k| * incorrect destructor function with the pointer */ \
| | 607| 3.02k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.02k]
| | ------------------
| | 608| 3.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.02k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.02k]
| | ------------------
------------------
131| |
132| 3.02k| igraph_lgl_yyset_in(instream, context.scanner);
133| |
134| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */
135| 3.02k| IGRAPH_FINALLY_ENTER();
136| 3.02k| int err = igraph_lgl_yyparse(&context);
137| 3.02k| IGRAPH_FINALLY_EXIT();
138| 3.02k| switch (err) {
139| 3.02k| case 0: /* success */
------------------
| Branch (139:5): [True: 3.02k, False: 0]
------------------
140| 3.02k| break;
141| 0| case 1: /* parse error */
------------------
| Branch (141:5): [True: 0, False: 3.02k]
------------------
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.02k]
------------------
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.02k]
------------------
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.02k| }
161| |
162| | /* Prepare attributes if needed */
163| 3.02k| if (names) {
------------------
| Branch (163:9): [True: 3.02k, False: 0]
------------------
164| 3.02k| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1));
------------------
| | 656| 3.02k| do { \
| | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.02k]
| | ------------------
------------------
165| 3.02k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name);
------------------
| | 603| 3.02k| do { \
| | 604| 3.02k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.02k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.02k| * incorrect destructor function with the pointer */ \
| | 607| 3.02k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.02k]
| | ------------------
| | 608| 3.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.02k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.02k]
| | ------------------
------------------
166| |
167| 3.02k| namerec = igraph_attribute_record_list_get_ptr(&name, 0);
168| 3.02k| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr));
------------------
| | 656| 3.02k| do { \
| | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.02k]
| | ------------------
------------------
169| 3.02k| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.02k| do { \
| | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.02k]
| | ------------------
------------------
170| 3.02k| IGRAPH_CHECK(igraph_strvector_update(
------------------
| | 656| 3.02k| do { \
| | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.02k]
| | ------------------
------------------
171| 3.02k| namerec->value.as_strvector, igraph_i_trie_borrow_keys(context.trie))
172| 3.02k| );
173| |
174| 3.02k| pname = &name;
175| 3.02k| }
176| |
177| 3.02k| if (weights == IGRAPH_ADD_WEIGHTS_YES ||
------------------
| Branch (177:9): [True: 0, False: 3.02k]
------------------
178| 3.02k| (weights == IGRAPH_ADD_WEIGHTS_IF_PRESENT && context.has_weights)) {
------------------
| Branch (178:10): [True: 3.02k, False: 0]
| Branch (178:54): [True: 159, False: 2.86k]
------------------
179| 159| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1));
------------------
| | 656| 159| do { \
| | 657| 159| igraph_error_t igraph_i_ret = (expr); \
| | 658| 159| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 159| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 159]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 159| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 159]
| | ------------------
------------------
180| 159| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight);
------------------
| | 603| 159| do { \
| | 604| 159| /* the following branch makes the compiler check the compatibility of \
| | 605| 159| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 159| * incorrect destructor function with the pointer */ \
| | 607| 159| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 159]
| | ------------------
| | 608| 159| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 159| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 159]
| | ------------------
------------------
181| |
182| 159| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0);
183| 159| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr));
------------------
| | 656| 159| do { \
| | 657| 159| igraph_error_t igraph_i_ret = (expr); \
| | 658| 159| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 159| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 159]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 159| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 159]
| | ------------------
------------------
184| 159| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC));
------------------
| | 656| 159| do { \
| | 657| 159| igraph_error_t igraph_i_ret = (expr); \
| | 658| 159| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 159| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 159]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 159| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 159]
| | ------------------
------------------
185| 159| igraph_vector_swap(weightrec->value.as_vector, context.weights);
186| |
187| 159| pweight = &weight;
188| 159| }
189| |
190| | /* Create graph */
191| 3.02k| IGRAPH_CHECK(igraph_empty(graph, 0, directed));
------------------
| | 656| 3.02k| do { \
| | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.02k]
| | ------------------
------------------
192| 3.02k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.02k| do { \
| | 604| 3.02k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.02k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.02k| * incorrect destructor function with the pointer */ \
| | 607| 3.02k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.02k]
| | ------------------
| | 608| 3.02k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.02k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.02k]
| | ------------------
------------------
193| 3.02k| IGRAPH_CHECK(igraph_add_vertices(graph, igraph_trie_size(&trie), pname));
------------------
| | 656| 3.02k| do { \
| | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.02k]
| | ------------------
------------------
194| 3.02k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));
------------------
| | 656| 3.02k| do { \
| | 657| 3.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.02k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.02k]
| | ------------------
------------------
195| |
196| 3.02k| if (pweight) {
------------------
| Branch (196:9): [True: 159, False: 2.86k]
------------------
197| 159| igraph_attribute_record_list_destroy(pweight);
198| 159| IGRAPH_FINALLY_CLEAN(1);
199| 159| }
200| 3.02k| if (pname) {
------------------
| Branch (200:9): [True: 3.02k, False: 0]
------------------
201| 3.02k| igraph_attribute_record_list_destroy(pname);
202| 3.02k| IGRAPH_FINALLY_CLEAN(1);
203| 3.02k| }
204| 3.02k| igraph_trie_destroy(&trie);
205| 3.02k| igraph_vector_int_destroy(&edges);
206| 3.02k| igraph_vector_destroy(&ws);
207| 3.02k| igraph_lgl_yylex_destroy(context.scanner);
208| 3.02k| IGRAPH_FINALLY_CLEAN(5);
209| |
210| 3.02k| return IGRAPH_SUCCESS;
211| 3.02k|}
igraph_write_graph_lgl:
271| 3.17k| igraph_bool_t isolates) {
272| 3.17k| igraph_eit_t it;
273| 3.17k| igraph_int_t actvertex = -1;
274| 3.17k| igraph_attribute_type_t nametype, weighttype;
275| 3.17k| const igraph_int_t vcount = igraph_vcount(graph), ecount = igraph_ecount(graph);
276| |
277| 3.17k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM),
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
278| 3.17k| &it));
279| 3.17k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
280| |
281| | /* Check if we have the names attribute */
282| 3.17k| if (names && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
------------------
| Branch (282:9): [True: 3.17k, False: 0]
| Branch (282:18): [True: 2.71k, False: 463]
------------------
283| 3.17k| names)) {
284| 2.71k| IGRAPH_WARNINGF("Names attribute '%s' does not exist.", names);
------------------
| | 777| 2.71k| do { \
| | 778| 2.71k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.71k| __VA_ARGS__); \
| | 780| 2.71k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.71k]
| | ------------------
------------------
285| 2.71k| names = NULL;
286| 2.71k| }
287| 3.17k| if (names) {
------------------
| Branch (287:9): [True: 463, False: 2.71k]
------------------
288| 463| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &nametype,
------------------
| | 656| 463| do { \
| | 657| 463| igraph_error_t igraph_i_ret = (expr); \
| | 658| 463| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 463| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 463]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 463| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 463]
| | ------------------
------------------
289| 463| IGRAPH_ATTRIBUTE_VERTEX, names));
290| 463| if (nametype != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (290:13): [True: 44, False: 419]
------------------
291| 44| IGRAPH_WARNINGF("Ignoring names attribute '%s', unknown attribute type.", names);
------------------
| | 777| 44| do { \
| | 778| 44| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 44| __VA_ARGS__); \
| | 780| 44| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 44]
| | ------------------
------------------
292| 44| names = NULL;
293| 44| }
294| 463| }
295| |
296| | /* Check the weights as well */
297| 3.17k| if (weights && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, weights)) {
------------------
| Branch (297:9): [True: 3.17k, False: 0]
| Branch (297:20): [True: 2.94k, False: 230]
------------------
298| 2.94k| IGRAPH_WARNINGF("Weights attribute '%s' does not exist.", weights);
------------------
| | 777| 2.94k| do { \
| | 778| 2.94k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.94k| __VA_ARGS__); \
| | 780| 2.94k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.94k]
| | ------------------
------------------
299| 2.94k| weights = NULL;
300| 2.94k| }
301| 3.17k| if (weights) {
------------------
| Branch (301:9): [True: 230, False: 2.94k]
------------------
302| 230| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &weighttype,
------------------
| | 656| 230| do { \
| | 657| 230| igraph_error_t igraph_i_ret = (expr); \
| | 658| 230| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 230| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 230]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 230| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 230]
| | ------------------
------------------
303| 230| IGRAPH_ATTRIBUTE_EDGE, weights));
304| 230| if (weighttype != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (304:13): [True: 50, False: 180]
------------------
305| 50| IGRAPH_WARNINGF("Ignoring weights attribute '%s', unknown attribute type.", weights);
------------------
| | 777| 50| do { \
| | 778| 50| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 50| __VA_ARGS__); \
| | 780| 50| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 50]
| | ------------------
------------------
306| 50| weights = NULL;
307| 50| }
308| 230| }
309| |
310| 3.17k| if (names == NULL && weights == NULL) {
------------------
| Branch (310:9): [True: 2.76k, False: 419]
| Branch (310:26): [True: 2.65k, False: 103]
------------------
311| | /* No names, no weights */
312| 247k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 247k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (312:16): [True: 244k, False: 2.65k]
------------------
313| 244k| igraph_int_t from, to;
314| 244k| int ret;
315| |
316| 244k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 244k| do { \
| | 657| 489k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 0, False: 244k]
| | ------------------
| | 658| 244k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 244k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 244k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 244k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 244k]
| | ------------------
------------------
317| 244k| if (from == actvertex) {
------------------
| Branch (317:17): [True: 235k, False: 9.50k]
------------------
318| 235k| ret = fprintf(outstream, "%" IGRAPH_PRId "\n", to);
319| 235k| } else {
320| 9.50k| actvertex = from;
321| 9.50k| ret = fprintf(outstream, "# %" IGRAPH_PRId "\n%" IGRAPH_PRId "\n", from, to);
322| 9.50k| }
323| 244k| if (ret < 0) {
------------------
| Branch (323:17): [True: 0, False: 244k]
------------------
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| 244k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 244k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
327| 244k| }
328| 2.65k| } else if (weights == NULL) {
------------------
| Branch (328:16): [True: 342, False: 180]
------------------
329| | /* No weights but use names */
330| 342| igraph_strvector_t nvec;
331| 342| IGRAPH_STRVECTOR_INIT_FINALLY(&nvec, vcount);
------------------
| | 62| 342| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 342| do { \
| | | | 657| 342| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 342| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 342| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 342]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 342| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 342]
| | | | ------------------
| | ------------------
| | 63| 342| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 342| do { \
| | | | 604| 342| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 342| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 342| * incorrect destructor function with the pointer */ \
| | | | 607| 342| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 342]
| | | | ------------------
| | | | 608| 342| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 342| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 342]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 342]
| | ------------------
------------------
332| 342| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 342| do { \
| | 657| 342| igraph_error_t igraph_i_ret = (expr); \
| | 658| 342| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 342| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 342]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 342| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 342]
| | ------------------
------------------
333| 342| igraph_vss_all(),
334| 342| &nvec));
335| 14.1k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 14.1k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (335:16): [True: 13.9k, False: 207]
------------------
336| 13.9k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 13.9k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 13.9k]
| | ------------------
| | 406| 13.9k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 13.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
337| 13.9k| igraph_int_t from, to;
338| 13.9k| int ret = 0;
339| 13.9k| const char *str1, *str2;
340| |
341| 13.9k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 13.9k| do { \
| | 657| 13.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.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| 13.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.9k]
| | ------------------
------------------
342| 13.9k| str2 = igraph_strvector_get(&nvec, to);
343| 13.9k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 13.9k| do { \
| | 657| 13.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 131, False: 13.8k]
| | | | ------------------
| | ------------------
| | 659| 131| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 131| do { \
| | | | 427| 131| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 131| return igraph_errno ; \
| | | | 429| 131| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 131| } \
| | 661| 13.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.8k]
| | ------------------
------------------
344| |
345| 13.8k| if (from == actvertex) {
------------------
| Branch (345:17): [True: 12.1k, False: 1.73k]
------------------
346| 12.1k| ret = fprintf(outstream, "%s\n", str2);
347| 12.1k| } else {
348| 1.73k| actvertex = from;
349| 1.73k| str1 = igraph_strvector_get(&nvec, from);
350| 1.73k| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 1.73k| do { \
| | 657| 1.73k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.73k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 4, False: 1.73k]
| | | | ------------------
| | ------------------
| | 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.73k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.73k]
| | ------------------
------------------
351| 1.73k| ret = fprintf(outstream, "# %s\n%s\n", str1, str2);
352| 1.73k| }
353| 13.8k| if (ret < 0) {
------------------
| Branch (353:17): [True: 0, False: 13.8k]
------------------
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.8k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 13.8k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
357| 13.8k| }
358| 207| igraph_strvector_destroy(&nvec);
359| 207| IGRAPH_FINALLY_CLEAN(1);
360| 207| } else if (names == NULL) {
------------------
| Branch (360:16): [True: 103, False: 77]
------------------
361| | /* No names but weights */
362| 103| igraph_vector_t wvec;
363| 103| IGRAPH_VECTOR_INIT_FINALLY(&wvec, ecount);
------------------
| | 104| 103| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 103| do { \
| | | | 657| 103| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 103| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 103| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 103]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 103| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 103]
| | | | ------------------
| | ------------------
| | 105| 103| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 103| do { \
| | | | 604| 103| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 103| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 103| * incorrect destructor function with the pointer */ \
| | | | 607| 103| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 103]
| | | | ------------------
| | | | 608| 103| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 103| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 103]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 103]
| | ------------------
------------------
364| 103| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 103| do { \
| | 657| 103| igraph_error_t igraph_i_ret = (expr); \
| | 658| 103| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 103| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 103]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 103| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 103]
| | ------------------
------------------
365| 103| igraph_ess_all(IGRAPH_EDGEORDER_ID),
366| 103| &wvec));
367| 71.1k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 71.1k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (367:16): [True: 71.0k, False: 103]
------------------
368| 71.0k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 71.0k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 71.0k]
| | ------------------
| | 406| 71.0k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 71.0k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
369| 71.0k| igraph_int_t from, to;
370| 71.0k| int ret1, ret2, ret3;
371| |
372| 71.0k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 71.0k| do { \
| | 657| 71.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 71.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 71.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 71.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| 71.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 71.0k]
| | ------------------
------------------
373| 71.0k| if (from == actvertex) {
------------------
| Branch (373:17): [True: 69.9k, False: 1.05k]
------------------
374| 69.9k| ret1 = fprintf(outstream, "%" IGRAPH_PRId " ", to);
375| 69.9k| } else {
376| 1.05k| actvertex = from;
377| 1.05k| ret1 = fprintf(outstream, "# %" IGRAPH_PRId "\n%" IGRAPH_PRId " ", from, to);
378| 1.05k| }
379| 71.0k| ret2 = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 71.0k|#define VECTOR(v) ((v).stor_begin)
------------------
380| 71.0k| ret3 = fputc('\n', outstream);
381| 71.0k| if (ret1 < 0 || ret2 < 0 || ret3 == EOF) {
------------------
| Branch (381:17): [True: 0, False: 71.0k]
| Branch (381:29): [True: 0, False: 71.0k]
| Branch (381:41): [True: 0, False: 71.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| 71.0k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 71.0k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
385| 71.0k| }
386| 103| igraph_vector_destroy(&wvec);
387| 103| IGRAPH_FINALLY_CLEAN(1);
388| 103| } else {
389| | /* Both names and weights */
390| 77| igraph_strvector_t nvec;
391| 77| igraph_vector_t wvec;
392| 77| IGRAPH_VECTOR_INIT_FINALLY(&wvec, ecount);
------------------
| | 104| 77| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 77| do { \
| | | | 657| 77| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 77| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 77| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 77]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 77| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 77]
| | | | ------------------
| | ------------------
| | 105| 77| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 77| do { \
| | | | 604| 77| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 77| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 77| * incorrect destructor function with the pointer */ \
| | | | 607| 77| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 77]
| | | | ------------------
| | | | 608| 77| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 77| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 77]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 77]
| | ------------------
------------------
393| 77| IGRAPH_STRVECTOR_INIT_FINALLY(&nvec, vcount);
------------------
| | 62| 77| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 77| do { \
| | | | 657| 77| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 77| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 77| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 77]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 77| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 77]
| | | | ------------------
| | ------------------
| | 63| 77| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 77| do { \
| | | | 604| 77| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 77| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 77| * incorrect destructor function with the pointer */ \
| | | | 607| 77| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 77]
| | | | ------------------
| | | | 608| 77| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 77| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 77]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 77]
| | ------------------
------------------
394| 77| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 77| do { \
| | 657| 77| igraph_error_t igraph_i_ret = (expr); \
| | 658| 77| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 77| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 77| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 77]
| | ------------------
------------------
395| 77| igraph_ess_all(IGRAPH_EDGEORDER_ID),
396| 77| &wvec));
397| 77| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 77| do { \
| | 657| 77| igraph_error_t igraph_i_ret = (expr); \
| | 658| 77| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 77| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 77| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 77]
| | ------------------
------------------
398| 77| igraph_vss_all(),
399| 77| &nvec));
400| 19.9k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 19.9k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (400:16): [True: 19.9k, False: 61]
------------------
401| 19.9k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 19.9k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 19.9k]
| | ------------------
| | 406| 19.9k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 19.9k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
402| 19.9k| igraph_int_t from, to;
403| 19.9k| int ret = 0, ret2;
404| 19.9k| const char *str1, *str2;
405| |
406| 19.9k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 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]
| | ------------------
------------------
407| 19.9k| str2 = igraph_strvector_get(&nvec, to);
408| 19.9k| IGRAPH_CHECK(check_name(str2));
------------------
| | 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: 15, False: 19.8k]
| | | | ------------------
| | ------------------
| | 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| 19.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.8k]
| | ------------------
------------------
409| |
410| 19.8k| if (from == actvertex) {
------------------
| Branch (410:17): [True: 19.5k, False: 347]
------------------
411| 19.5k| ret = fprintf(outstream, "%s ", str2);
412| 19.5k| } else {
413| 347| actvertex = from;
414| 347| str1 = igraph_strvector_get(&nvec, from);
415| 347| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 347| do { \
| | 657| 347| igraph_error_t igraph_i_ret = (expr); \
| | 658| 347| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 347| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 346]
| | | | ------------------
| | ------------------
| | 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| 347| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 346]
| | ------------------
------------------
416| 346| ret = fprintf(outstream, "# %s\n%s ", str1, str2);
417| 346| }
418| 19.8k| if (ret < 0) {
------------------
| Branch (418:17): [True: 0, False: 19.8k]
------------------
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.8k| ret = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 19.8k|#define VECTOR(v) ((v).stor_begin)
------------------
422| 19.8k| ret2 = fputc('\n', outstream);
423| 19.8k| if (ret < 0 || ret2 == EOF) {
------------------
| Branch (423:17): [True: 0, False: 19.8k]
| Branch (423:28): [True: 0, False: 19.8k]
------------------
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.8k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 19.8k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
427| 19.8k| }
428| 61| igraph_strvector_destroy(&nvec);
429| 61| igraph_vector_destroy(&wvec);
430| 61| IGRAPH_FINALLY_CLEAN(2);
431| 61| }
432| |
433| 3.02k| if (isolates) {
------------------
| Branch (433:9): [True: 0, False: 3.02k]
------------------
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.02k| igraph_eit_destroy(&it);
464| 3.02k| IGRAPH_FINALLY_CLEAN(1);
465| 3.02k| return IGRAPH_SUCCESS;
466| 3.02k|}
lgl.c:check_name:
214| 35.9k|static igraph_error_t check_name(const char *name) {
215| 35.9k| size_t len = 0;
216| |
217| 46.7M| for (; *name != '\0'; name++, len++) {
------------------
| Branch (217:12): [True: 46.6M, False: 35.8k]
------------------
218| 46.6M| if ( *name <= 0x020 /* space or non-printable */
------------------
| Branch (218:16): [True: 56, False: 46.6M]
------------------
219| 46.6M| || *name == 0x7f /* del */
------------------
| Branch (219:16): [True: 5, False: 46.6M]
------------------
220| 46.6M| || *name == '#') {
------------------
| Branch (220:16): [True: 59, False: 46.6M]
------------------
221| 120| IGRAPH_ERRORF("The LGL format does not allow non-printable characters, spaces or '#' in vertex names. "
------------------
| | 464| 120| do { \
| | 465| 120| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 120| igraph_errno, __VA_ARGS__) ; \
| | 467| 120| return igraph_errno; \
| | 468| 120| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
222| 120| "Character code 0x%02X found.", IGRAPH_EINVAL,
223| 120| *name);
224| 120| }
225| 46.6M| }
226| 35.8k| if (len == 0) {
------------------
| Branch (226:9): [True: 31, False: 35.8k]
------------------
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.8k| return IGRAPH_SUCCESS;
230| 35.8k|}
igraph_read_graph_ncol:
110| 3.08k| igraph_bool_t directed) {
111| |
112| 3.08k| igraph_vector_int_t edges;
113| 3.08k| igraph_vector_t ws;
114| 3.08k| igraph_trie_t trie = IGRAPH_TRIE_NULL;
------------------
| | 52| 3.08k| { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 60| 3.08k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 44| 3.08k|#define IGRAPH_VECTOR_PTR_NULL { 0,0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 99| 3.08k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
| | ------------------
| | 53| 3.08k| 0, 0, IGRAPH_STRVECTOR_NULL }
| | ------------------
| | | | 60| 3.08k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
------------------
115| 3.08k| igraph_int_t no_of_nodes;
116| 3.08k| igraph_int_t no_predefined = 0;
117| 3.08k| igraph_attribute_record_list_t name, weight;
118| 3.08k| igraph_attribute_record_list_t *pname = NULL, *pweight = NULL;
119| 3.08k| igraph_attribute_record_t *namerec, *weightrec;
120| 3.08k| const char *namestr = "name", *weightstr = "weight";
121| 3.08k| igraph_i_ncol_parsedata_t context;
122| |
123| 3.08k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0);
------------------
| | 119| 3.08k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.08k| do { \
| | | | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.08k]
| | | | ------------------
| | ------------------
| | 120| 3.08k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.08k| do { \
| | | | 604| 3.08k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.08k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.08k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.08k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.08k]
| | | | ------------------
| | | | 608| 3.08k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.08k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.08k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.08k]
| | ------------------
------------------
124| |
125| 3.08k| IGRAPH_TRIE_INIT_FINALLY(&trie, names);
------------------
| | 55| 3.08k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.08k| do { \
| | | | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.08k]
| | | | ------------------
| | ------------------
| | 56| 3.08k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.08k| do { \
| | | | 604| 3.08k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.08k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.08k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.08k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.08k]
| | | | ------------------
| | | | 608| 3.08k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.08k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.08k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.08k]
| | ------------------
------------------
126| 3.08k| IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);
------------------
| | 104| 3.08k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.08k| do { \
| | | | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.08k]
| | | | ------------------
| | ------------------
| | 105| 3.08k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.08k| do { \
| | | | 604| 3.08k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.08k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.08k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.08k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.08k]
| | | | ------------------
| | | | 608| 3.08k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.08k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.08k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.08k]
| | ------------------
------------------
127| |
128| | /* Add the predefined names, if any */
129| 3.08k| if (predefnames != 0) {
------------------
| Branch (129:9): [True: 0, False: 3.08k]
------------------
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.08k| context.has_weights = false;
144| 3.08k| context.vector = &edges;
145| 3.08k| context.weights = &ws;
146| 3.08k| context.trie = ≜
147| 3.08k| context.errmsg[0] = '\0';
148| 3.08k| context.igraph_errno = IGRAPH_SUCCESS;
149| |
150| 3.08k| igraph_ncol_yylex_init_extra(&context, &context.scanner);
151| 3.08k| IGRAPH_FINALLY(igraph_ncol_yylex_destroy_wrapper, context.scanner);
------------------
| | 603| 3.08k| do { \
| | 604| 3.08k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.08k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.08k| * incorrect destructor function with the pointer */ \
| | 607| 3.08k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.08k]
| | ------------------
| | 608| 3.08k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.08k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.08k]
| | ------------------
------------------
152| |
153| 3.08k| igraph_ncol_yyset_in(instream, context.scanner);
154| |
155| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */
156| 3.08k| IGRAPH_FINALLY_ENTER();
157| 3.08k| int err = igraph_ncol_yyparse(&context);
158| 3.08k| IGRAPH_FINALLY_EXIT();
159| 3.08k| switch (err) {
160| 3.08k| case 0: /* success */
------------------
| Branch (160:5): [True: 3.08k, False: 0]
------------------
161| 3.08k| break;
162| 0| case 1: /* parse error */
------------------
| Branch (162:5): [True: 0, False: 3.08k]
------------------
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.08k]
------------------
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.08k]
------------------
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.08k| }
182| |
183| 3.08k| if (predefnames != 0 &&
------------------
| Branch (183:9): [True: 0, False: 3.08k]
------------------
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.08k| if (names) {
------------------
| Branch (189:9): [True: 3.08k, False: 0]
------------------
190| 3.08k| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1));
------------------
| | 656| 3.08k| do { \
| | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.08k]
| | ------------------
------------------
191| 3.08k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name);
------------------
| | 603| 3.08k| do { \
| | 604| 3.08k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.08k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.08k| * incorrect destructor function with the pointer */ \
| | 607| 3.08k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.08k]
| | ------------------
| | 608| 3.08k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.08k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.08k]
| | ------------------
------------------
192| |
193| 3.08k| namerec = igraph_attribute_record_list_get_ptr(&name, 0);
194| 3.08k| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr));
------------------
| | 656| 3.08k| do { \
| | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.08k]
| | ------------------
------------------
195| 3.08k| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.08k| do { \
| | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.08k]
| | ------------------
------------------
196| 3.08k| IGRAPH_CHECK(igraph_strvector_update(
------------------
| | 656| 3.08k| do { \
| | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.08k]
| | ------------------
------------------
197| 3.08k| namerec->value.as_strvector, igraph_i_trie_borrow_keys(context.trie))
198| 3.08k| );
199| |
200| 3.08k| pname = &name;
201| 3.08k| }
202| |
203| 3.08k| if (weights == IGRAPH_ADD_WEIGHTS_YES ||
------------------
| Branch (203:9): [True: 0, False: 3.08k]
------------------
204| 3.08k| (weights == IGRAPH_ADD_WEIGHTS_IF_PRESENT && context.has_weights)) {
------------------
| Branch (204:10): [True: 3.08k, False: 0]
| Branch (204:54): [True: 167, False: 2.91k]
------------------
205| 167| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1));
------------------
| | 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]
| | ------------------
------------------
206| 167| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight);
------------------
| | 603| 167| do { \
| | 604| 167| /* the following branch makes the compiler check the compatibility of \
| | 605| 167| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 167| * incorrect destructor function with the pointer */ \
| | 607| 167| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 167]
| | ------------------
| | 608| 167| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 167| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 167]
| | ------------------
------------------
207| |
208| 167| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0);
209| 167| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr));
------------------
| | 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]
| | ------------------
------------------
210| 167| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC));
------------------
| | 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]
| | ------------------
------------------
211| 167| igraph_vector_swap(weightrec->value.as_vector, context.weights);
212| |
213| 167| pweight = &weight;
214| 167| }
215| |
216| 3.08k| if (igraph_vector_int_empty(&edges)) {
------------------
| Branch (216:9): [True: 829, False: 2.25k]
------------------
217| 829| no_of_nodes = 0;
218| 2.25k| } else {
219| 2.25k| no_of_nodes = igraph_vector_int_max(&edges) + 1;
220| 2.25k| }
221| |
222| | /* Create graph */
223| 3.08k| IGRAPH_CHECK(igraph_empty(graph, 0, directed));
------------------
| | 656| 3.08k| do { \
| | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.08k]
| | ------------------
------------------
224| 3.08k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.08k| do { \
| | 604| 3.08k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.08k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.08k| * incorrect destructor function with the pointer */ \
| | 607| 3.08k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.08k]
| | ------------------
| | 608| 3.08k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.08k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.08k]
| | ------------------
------------------
225| 3.08k| IGRAPH_CHECK(igraph_add_vertices(graph, no_of_nodes, pname));
------------------
| | 656| 3.08k| do { \
| | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.08k]
| | ------------------
------------------
226| 3.08k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));
------------------
| | 656| 3.08k| do { \
| | 657| 3.08k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.08k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.08k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.08k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.08k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.08k]
| | ------------------
------------------
227| |
228| 3.08k| if (pname) {
------------------
| Branch (228:9): [True: 3.08k, False: 0]
------------------
229| 3.08k| igraph_attribute_record_list_destroy(pname);
230| 3.08k| IGRAPH_FINALLY_CLEAN(1);
231| 3.08k| }
232| 3.08k| if (pweight) {
------------------
| Branch (232:9): [True: 167, False: 2.91k]
------------------
233| 167| igraph_attribute_record_list_destroy(pweight);
234| 167| IGRAPH_FINALLY_CLEAN(1);
235| 167| }
236| 3.08k| igraph_vector_destroy(&ws);
237| 3.08k| igraph_trie_destroy(&trie);
238| 3.08k| igraph_vector_int_destroy(&edges);
239| 3.08k| igraph_ncol_yylex_destroy(context.scanner);
240| 3.08k| IGRAPH_FINALLY_CLEAN(5); /* +1 for 'graph' */
241| |
242| 3.08k| return IGRAPH_SUCCESS;
243| 3.08k|}
igraph_write_graph_ncol:
301| 3.17k| const char *names, const char *weights) {
302| 3.17k| igraph_eit_t it;
303| 3.17k| igraph_attribute_type_t nametype, weighttype;
304| |
305| 3.17k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID),
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
306| 3.17k| &it));
307| 3.17k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
308| |
309| | /* Check if we have the names attribute */
310| 3.17k| if (names && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
------------------
| Branch (310:9): [True: 3.17k, False: 0]
| Branch (310:18): [True: 2.71k, False: 463]
------------------
311| 3.17k| names)) {
312| 2.71k| IGRAPH_WARNINGF("Names attribute '%s' does not exist.", names);
------------------
| | 777| 2.71k| do { \
| | 778| 2.71k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.71k| __VA_ARGS__); \
| | 780| 2.71k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.71k]
| | ------------------
------------------
313| 2.71k| names = NULL;
314| 2.71k| }
315| 3.17k| if (names) {
------------------
| Branch (315:9): [True: 463, False: 2.71k]
------------------
316| 463| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &nametype,
------------------
| | 656| 463| do { \
| | 657| 463| igraph_error_t igraph_i_ret = (expr); \
| | 658| 463| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 463| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 463]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 463| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 463]
| | ------------------
------------------
317| 463| IGRAPH_ATTRIBUTE_VERTEX, names));
318| 463| if (nametype != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (318:13): [True: 44, False: 419]
------------------
319| 44| IGRAPH_WARNINGF("Ignoring names attribute '%s', "
------------------
| | 777| 44| do { \
| | 778| 44| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 44| __VA_ARGS__); \
| | 780| 44| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 44]
| | ------------------
------------------
320| 44| "attribute type is not a string.", names);
321| 44| names = NULL;
322| 44| }
323| 463| }
324| |
325| | /* Check the weights as well */
326| 3.17k| if (weights && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, weights)) {
------------------
| Branch (326:9): [True: 3.17k, False: 0]
| Branch (326:20): [True: 2.94k, False: 230]
------------------
327| 2.94k| IGRAPH_WARNINGF("Weights attribute '%s' does not exist.", weights);
------------------
| | 777| 2.94k| do { \
| | 778| 2.94k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2.94k| __VA_ARGS__); \
| | 780| 2.94k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2.94k]
| | ------------------
------------------
328| 2.94k| weights = NULL;
329| 2.94k| }
330| 3.17k| if (weights) {
------------------
| Branch (330:9): [True: 230, False: 2.94k]
------------------
331| 230| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &weighttype,
------------------
| | 656| 230| do { \
| | 657| 230| igraph_error_t igraph_i_ret = (expr); \
| | 658| 230| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 230| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 230]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 230| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 230]
| | ------------------
------------------
332| 230| IGRAPH_ATTRIBUTE_EDGE, weights));
333| 230| if (weighttype != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (333:13): [True: 50, False: 180]
------------------
334| 50| IGRAPH_WARNINGF("Ignoring weights attribute '%s', "
------------------
| | 777| 50| do { \
| | 778| 50| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 50| __VA_ARGS__); \
| | 780| 50| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 50]
| | ------------------
------------------
335| 50| "attribute type is not numeric.", weights);
336| 50| weights = NULL;
337| 50| }
338| 230| }
339| |
340| 3.17k| if (names == NULL && weights == NULL) {
------------------
| Branch (340:9): [True: 2.76k, False: 419]
| Branch (340:26): [True: 2.65k, False: 103]
------------------
341| | /* No names, no weights */
342| 247k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 247k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (342:16): [True: 244k, False: 2.65k]
------------------
343| 244k| igraph_int_t from, to;
344| 244k| int ret;
345| |
346| 244k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 244k| do { \
| | 657| 489k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 244k, False: 0]
| | ------------------
| | 658| 244k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 244k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 244k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 244k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 244k]
| | ------------------
------------------
347| 244k| ret = fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId "\n", from, to);
348| 244k| if (ret < 0) {
------------------
| Branch (348:17): [True: 0, False: 244k]
------------------
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| 244k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 244k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
352| 244k| }
353| 2.65k| } else if (weights == NULL) {
------------------
| Branch (353:16): [True: 342, False: 180]
------------------
354| | /* No weights, but use names */
355| 342| igraph_strvector_t nvec;
356| 342| IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
------------------
| | 656| 342| do { \
| | 657| 342| igraph_error_t igraph_i_ret = (expr); \
| | 658| 342| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 342| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 342]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 342| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 342]
| | ------------------
------------------
357| 342| IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
------------------
| | 603| 342| do { \
| | 604| 342| /* the following branch makes the compiler check the compatibility of \
| | 605| 342| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 342| * incorrect destructor function with the pointer */ \
| | 607| 342| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 342]
| | ------------------
| | 608| 342| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 342| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 342]
| | ------------------
------------------
358| 342| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 342| do { \
| | 657| 342| igraph_error_t igraph_i_ret = (expr); \
| | 658| 342| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 342| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 342]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 342| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 342]
| | ------------------
------------------
359| 342| igraph_vss_all(),
360| 342| &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.5k, False: 253]
------------------
362| 15.5k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 15.5k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 15.5k, False: 0]
| | ------------------
| | 406| 15.5k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
363| 15.5k| igraph_int_t from, to;
364| 15.5k| int ret = 0;
365| 15.5k| const char *str1, *str2;
366| |
367| 15.5k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 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: 0, False: 15.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| 15.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.5k]
| | ------------------
------------------
368| 15.5k| str1 = igraph_strvector_get(&nvec, from);
369| 15.5k| IGRAPH_CHECK(check_name(str1));
------------------
| | 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: 86, False: 15.4k]
| | | | ------------------
| | ------------------
| | 659| 86| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 86| do { \
| | | | 427| 86| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 86| return igraph_errno ; \
| | | | 429| 86| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 86| } \
| | 661| 15.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.4k]
| | ------------------
------------------
370| 15.4k| str2 = igraph_strvector_get(&nvec, to);
371| 15.4k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 15.4k| do { \
| | 657| 15.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 15.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 15.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 3, False: 15.4k]
| | | | ------------------
| | ------------------
| | 659| 3| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 3| do { \
| | | | 427| 3| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 3| return igraph_errno ; \
| | | | 429| 3| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 3| } \
| | 661| 15.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.4k]
| | ------------------
------------------
372| 15.4k| ret = fprintf(outstream, "%s %s\n", str1, str2);
373| 15.4k| if (ret < 0) {
------------------
| Branch (373:17): [True: 0, False: 15.4k]
------------------
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.4k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 15.4k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
377| 15.4k| }
378| 253| igraph_strvector_destroy(&nvec);
379| 253| IGRAPH_FINALLY_CLEAN(1);
380| 253| } else if (names == NULL) {
------------------
| Branch (380:16): [True: 103, False: 77]
------------------
381| | /* No names but weights */
382| 103| igraph_vector_t wvec;
383| 103| IGRAPH_VECTOR_INIT_FINALLY(&wvec, igraph_ecount(graph));
------------------
| | 104| 103| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 103| do { \
| | | | 657| 103| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 103| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 103| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 103]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 103| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 103]
| | | | ------------------
| | ------------------
| | 105| 103| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 103| do { \
| | | | 604| 103| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 103| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 103| * incorrect destructor function with the pointer */ \
| | | | 607| 103| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 103]
| | | | ------------------
| | | | 608| 103| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 103| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 103]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 103]
| | ------------------
------------------
384| 103| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 103| do { \
| | 657| 103| igraph_error_t igraph_i_ret = (expr); \
| | 658| 103| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 103| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 103]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 103| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 103]
| | ------------------
------------------
385| 103| igraph_ess_all(IGRAPH_EDGEORDER_ID),
386| 103| &wvec));
387| 71.1k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 71.1k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (387:16): [True: 71.0k, False: 103]
------------------
388| 71.0k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 71.0k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 71.0k, False: 0]
| | ------------------
| | 406| 71.0k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
389| 71.0k| igraph_int_t from, to;
390| 71.0k| int ret1, ret2, ret3;
391| |
392| 71.0k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 71.0k| do { \
| | 657| 71.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 71.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 71.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 71.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| 71.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 71.0k]
| | ------------------
------------------
393| 71.0k| ret1 = fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " ", from, to);
394| 71.0k| ret2 = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 71.0k|#define VECTOR(v) ((v).stor_begin)
------------------
395| 71.0k| ret3 = fputc('\n', outstream);
396| 71.0k| if (ret1 < 0 || ret2 < 0 || ret3 == EOF) {
------------------
| Branch (396:17): [True: 0, False: 71.0k]
| Branch (396:29): [True: 0, False: 71.0k]
| Branch (396:41): [True: 0, False: 71.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| 71.0k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 71.0k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
400| 71.0k| }
401| 103| igraph_vector_destroy(&wvec);
402| 103| IGRAPH_FINALLY_CLEAN(1);
403| 103| } else {
404| | /* Both names and weights */
405| 77| igraph_strvector_t nvec;
406| 77| igraph_vector_t wvec;
407| 77| IGRAPH_VECTOR_INIT_FINALLY(&wvec, igraph_ecount(graph));
------------------
| | 104| 77| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 77| do { \
| | | | 657| 77| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 77| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 77| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 77]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 77| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 77]
| | | | ------------------
| | ------------------
| | 105| 77| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 77| do { \
| | | | 604| 77| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 77| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 77| * incorrect destructor function with the pointer */ \
| | | | 607| 77| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 77]
| | | | ------------------
| | | | 608| 77| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 77| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 77]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 77]
| | ------------------
------------------
408| 77| IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
------------------
| | 656| 77| do { \
| | 657| 77| igraph_error_t igraph_i_ret = (expr); \
| | 658| 77| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 77| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 77| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 77]
| | ------------------
------------------
409| 77| IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
------------------
| | 603| 77| do { \
| | 604| 77| /* the following branch makes the compiler check the compatibility of \
| | 605| 77| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 77| * incorrect destructor function with the pointer */ \
| | 607| 77| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 77]
| | ------------------
| | 608| 77| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 77| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 77]
| | ------------------
------------------
410| 77| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 77| do { \
| | 657| 77| igraph_error_t igraph_i_ret = (expr); \
| | 658| 77| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 77| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 77| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 77]
| | ------------------
------------------
411| 77| igraph_ess_all(IGRAPH_EDGEORDER_ID),
412| 77| &wvec));
413| 77| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 77| do { \
| | 657| 77| igraph_error_t igraph_i_ret = (expr); \
| | 658| 77| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 77| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 77| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 77]
| | ------------------
------------------
414| 77| igraph_vss_all(),
415| 77| &nvec));
416| 19.9k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 19.9k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (416:16): [True: 19.9k, False: 69]
------------------
417| 19.9k| igraph_int_t edge = 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)
| | ------------------
------------------
418| 19.9k| igraph_int_t from, to;
419| 19.9k| int ret = 0, ret2 = 0;
420| 19.9k| const char *str1, *str2;
421| |
422| 19.9k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 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]
| | ------------------
------------------
423| 19.9k| str1 = igraph_strvector_get(&nvec, from);
424| 19.9k| IGRAPH_CHECK(check_name(str1));
------------------
| | 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: 7, False: 19.9k]
| | | | ------------------
| | ------------------
| | 659| 7| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 7| do { \
| | | | 427| 7| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 7| return igraph_errno ; \
| | | | 429| 7| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 7| } \
| | 661| 19.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.9k]
| | ------------------
------------------
425| 19.9k| str2 = igraph_strvector_get(&nvec, to);
426| 19.9k| IGRAPH_CHECK(check_name(str2));
------------------
| | 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: 1, False: 19.9k]
| | | | ------------------
| | ------------------
| | 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.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19.9k]
| | ------------------
------------------
427| 19.9k| ret = fprintf(outstream, "%s %s ", str1, str2);
428| 19.9k| if (ret < 0) {
------------------
| Branch (428:17): [True: 0, False: 19.9k]
------------------
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.9k| ret = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 19.9k|#define VECTOR(v) ((v).stor_begin)
------------------
432| 19.9k| ret2 = fputc('\n', outstream);
433| 19.9k| if (ret < 0 || ret2 == EOF) {
------------------
| Branch (433:17): [True: 0, False: 19.9k]
| Branch (433:28): [True: 0, False: 19.9k]
------------------
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.9k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 19.9k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
437| 19.9k| }
438| 69| igraph_strvector_destroy(&nvec);
439| 69| igraph_vector_destroy(&wvec);
440| 69| IGRAPH_FINALLY_CLEAN(2);
441| 69| }
442| |
443| 3.08k| igraph_eit_destroy(&it);
444| 3.08k| IGRAPH_FINALLY_CLEAN(1);
445| 3.08k| return IGRAPH_SUCCESS;
446| 3.17k|}
ncol.c:check_name:
246| 70.8k|static igraph_error_t check_name(const char *name) {
247| 70.8k| size_t len = 0;
248| |
249| 72.0M| for (; *name != '\0'; name++, len++) {
------------------
| Branch (249:12): [True: 71.9M, False: 70.7k]
------------------
250| 71.9M| if ( *name <= 0x020 /* space or non-printable */
------------------
| Branch (250:16): [True: 61, False: 71.9M]
------------------
251| 71.9M| || *name == 0x7f /* del */) {
------------------
| Branch (251:16): [True: 5, False: 71.9M]
------------------
252| 66| IGRAPH_ERRORF("The NCOL format does not allow non-printable characters or spaces in vertex names. "
------------------
| | 464| 66| do { \
| | 465| 66| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 66| igraph_errno, __VA_ARGS__) ; \
| | 467| 66| return igraph_errno; \
| | 468| 66| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
253| 66| "Character code 0x%02X found.", IGRAPH_EINVAL,
254| 66| *name);
255| 66| }
256| 71.9M| }
257| 70.7k| if (len == 0) {
------------------
| Branch (257:9): [True: 31, False: 70.7k]
------------------
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.7k| return IGRAPH_SUCCESS;
261| 70.7k|}
igraph_write_graph_pajek:
397| 3.17k|igraph_error_t igraph_write_graph_pajek(const igraph_t *graph, FILE *outstream) {
398| 3.17k| igraph_int_t no_of_nodes = igraph_vcount(graph);
399| |
400| 3.17k| igraph_attribute_type_t vtypes[V_LAST], etypes[E_LAST];
401| 3.17k| igraph_bool_t write_vertex_attrs = false;
402| |
403| | /* Same order as the #define's */
404| 3.17k| const char *vnames[] = { "name", "x", "y", "z", "shape", "xfact", "yfact",
405| 3.17k| "labeldist", "labeldegree2", "framewidth",
406| 3.17k| "fontsize", "rotation", "radius",
407| 3.17k| "diamondratio", "labeldegree",
408| 3.17k| "font", "url", "color", "framecolor",
409| 3.17k| "labelcolor"
410| 3.17k| };
411| 3.17k| IGRAPH_STATIC_ASSERT(sizeof(vnames) / sizeof(vnames[0]) == V_LAST);
------------------
| | 68| 3.17k|#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.17k| const char *vnumnames[] = { "xfact", "yfact", "labeldist",
416| 3.17k| "labeldegree2", "framewidth", "fontsize",
417| 3.17k| "rotation", "radius", "diamondratio",
418| 3.17k| "labeldegree"
419| 3.17k| };
420| 3.17k| const char *vnumnames2[] = { "x_fact", "y_fact", "lr", "lphi", "bw",
421| 3.17k| "fos", "phi", "r", "q", "la"
422| 3.17k| };
423| 3.17k| IGRAPH_STATIC_ASSERT(sizeof(vnumnames) == sizeof(vnumnames2));
------------------
| | 68| 3.17k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
424| |
425| 3.17k| const char *vstrnames[] = { "font", "url", "color", "framecolor",
426| 3.17k| "labelcolor"
427| 3.17k| };
428| 3.17k| const char *vstrnames2[] = { "font", "url", "ic", "bc", "lc" };
429| 3.17k| IGRAPH_STATIC_ASSERT(sizeof(vstrnames) == sizeof(vstrnames2));
------------------
| | 68| 3.17k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
430| |
431| | /* Same order as the #define's */
432| 3.17k| const char *enames[] = { "weight" };
433| 3.17k| IGRAPH_STATIC_ASSERT(sizeof(enames) / sizeof(enames[0]) == E_LAST);
------------------
| | 68| 3.17k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
434| |
435| 3.17k| const char *enumnames[] = { "arrowsize", "edgewidth", "hook1", "hook2",
436| 3.17k| "angle1", "angle2", "velocity1", "velocity2",
437| 3.17k| "arrowpos", "labelpos", "labelangle",
438| 3.17k| "labelangle2", "labeldegree", "fontsize"
439| 3.17k| };
440| 3.17k| const char *enumnames2[] = { "s", "w", "h1", "h2", "a1", "a2", "k1", "k2",
441| 3.17k| "ap", "lp", "lr", "lphi", "la", "fos"
442| 3.17k| };
443| 3.17k| IGRAPH_STATIC_ASSERT(sizeof(enumnames) == sizeof(enumnames2));
------------------
| | 68| 3.17k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
444| |
445| 3.17k| const char *estrnames[] = { "arrowtype", "linepattern", "label",
446| 3.17k| "labelcolor", "color", "font"
447| 3.17k| };
448| 3.17k| const char *estrnames2[] = { "a", "p", "l", "lc", "c", "font" };
449| 3.17k| IGRAPH_STATIC_ASSERT(sizeof(estrnames) == sizeof(estrnames2));
------------------
| | 68| 3.17k|#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.17k| const char *newline = "\n";
455| |
456| 3.17k| igraph_es_t es;
457| 3.17k| igraph_eit_t eit;
458| |
459| 3.17k| igraph_vector_t numv;
460| 3.17k| igraph_strvector_t strv;
461| |
462| 3.17k| igraph_vector_int_t ex_numa;
463| 3.17k| igraph_vector_int_t ex_stra;
464| 3.17k| igraph_vector_int_t vx_numa;
465| 3.17k| igraph_vector_int_t vx_stra;
466| |
467| 3.17k| const char *s;
468| 3.17k| char *escaped;
469| |
470| 3.17k| igraph_bool_t bipartite = false;
471| 3.17k| igraph_vector_int_t bip_index, bip_index2;
472| 3.17k| igraph_vector_bool_t bvec;
473| 3.17k| igraph_int_t notop = 0, nobottom = 0;
474| |
475| 3.17k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.17k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 105| 3.17k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.17k]
| | ------------------
------------------
476| 3.17k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.17k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 63| 3.17k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.17k]
| | ------------------
------------------
477| |
478| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ex_numa, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
479| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ex_stra, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
480| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vx_numa, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
481| 3.17k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vx_stra, 0);
------------------
| | 119| 3.17k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.17k| do { \
| | | | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | 120| 3.17k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.17k| do { \
| | | | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.17k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.17k]
| | | | ------------------
| | | | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.17k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.17k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.17k]
| | ------------------
------------------
482| |
483| | /* Check if graph is bipartite, i.e. whether it has a Boolean 'type' vertex attribute. */
484| 3.17k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, "type")) {
------------------
| Branch (484:9): [True: 30, False: 3.14k]
------------------
485| 30| igraph_attribute_type_t type_type;
486| 30| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &type_type, IGRAPH_ATTRIBUTE_VERTEX, "type"));
------------------
| | 656| 30| do { \
| | 657| 30| igraph_error_t igraph_i_ret = (expr); \
| | 658| 30| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 30| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 30]
| | ------------------
------------------
487| 30| if (type_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (487:13): [True: 29, False: 1]
------------------
488| 29| 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| 29| IGRAPH_VECTOR_INT_INIT_FINALLY(&bip_index, no_of_nodes);
------------------
| | 119| 29| do { IGRAPH_CHECK(igraph_vector_int_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]
| | | | ------------------
| | ------------------
| | 120| 29| IGRAPH_FINALLY(igraph_vector_int_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 (120:64): [Folded, False: 29]
| | ------------------
------------------
492| 29| IGRAPH_VECTOR_INT_INIT_FINALLY(&bip_index2, no_of_nodes);
------------------
| | 119| 29| do { IGRAPH_CHECK(igraph_vector_int_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]
| | | | ------------------
| | ------------------
| | 120| 29| IGRAPH_FINALLY(igraph_vector_int_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 (120:64): [Folded, False: 29]
| | ------------------
------------------
493| 29| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&bvec, 1);
------------------
| | 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]
| | ------------------
------------------
494| 430| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (494:38): [True: 401, False: 29]
------------------
495| 401| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph,
------------------
| | 656| 401| do { \
| | 657| 401| igraph_error_t igraph_i_ret = (expr); \
| | 658| 401| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 401| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 401]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 401| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 401]
| | ------------------
------------------
496| 401| "type", igraph_vss_1(i), &bvec));
497| 401| if (VECTOR(bvec)[0]) {
------------------
| | 60| 401|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (497:21): [True: 0, False: 401]
------------------
498| 0| notop++;
499| 401| } else {
500| 401| nobottom++;
501| 401| }
502| 401| }
503| 430| for (igraph_int_t i = 0, bptr = 0, tptr = nobottom; i < no_of_nodes; i++) {
------------------
| Branch (503:65): [True: 401, False: 29]
------------------
504| 401| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph,
------------------
| | 656| 401| do { \
| | 657| 401| igraph_error_t igraph_i_ret = (expr); \
| | 658| 401| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 401| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 401]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 401| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 401]
| | ------------------
------------------
505| 401| "type", igraph_vss_1(i), &bvec));
506| 401| if (VECTOR(bvec)[0]) {
------------------
| | 60| 401|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (506:21): [True: 0, False: 401]
------------------
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| 401| } else {
511| 401| VECTOR(bip_index)[bptr] = i;
------------------
| | 60| 401|#define VECTOR(v) ((v).stor_begin)
------------------
512| 401| VECTOR(bip_index2)[i] = bptr;
------------------
| | 60| 401|#define VECTOR(v) ((v).stor_begin)
------------------
513| 401| bptr++;
514| 401| }
515| 401| }
516| 29| igraph_vector_bool_destroy(&bvec);
517| 29| IGRAPH_FINALLY_CLEAN(1);
518| 29| }
519| 30| }
520| |
521| | /* Write header */
522| 3.17k| if (bipartite) {
------------------
| Branch (522:9): [True: 29, False: 3.15k]
------------------
523| 29| if (fprintf(outstream, "*Vertices %" IGRAPH_PRId " %" IGRAPH_PRId "%s", no_of_nodes, nobottom,
------------------
| Branch (523:13): [True: 0, False: 29]
------------------
524| 29| 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.15k| } else {
528| 3.15k| if (fprintf(outstream, "*Vertices %" IGRAPH_PRId "%s", no_of_nodes, newline) < 0) {
------------------
| Branch (528:13): [True: 0, False: 3.15k]
------------------
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.15k| }
532| |
533| | /* Check the vertex attributes, and determine if we need to write them. */
534| 3.17k| memset(vtypes, 0, sizeof(vtypes[0])*V_LAST);
------------------
| | 263| 3.17k|#define V_LAST 20
------------------
535| 66.7k| for (igraph_int_t i = 0; i < V_LAST; i++) {
------------------
| | 263| 66.7k|#define V_LAST 20
------------------
| Branch (535:30): [True: 63.5k, False: 3.17k]
------------------
536| 63.5k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vnames[i])) {
------------------
| Branch (536:13): [True: 141, False: 63.4k]
------------------
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| 63.4k| } else {
541| 63.4k| vtypes[i] = (igraph_attribute_type_t) -1;
542| 63.4k| }
543| 63.5k| }
544| 34.9k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(vnumnames) / sizeof(vnumnames[0])); i++) {
------------------
| Branch (544:30): [True: 31.7k, False: 3.17k]
------------------
545| 31.7k| igraph_attribute_type_t type;
546| 31.7k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vnumnames[i])) {
------------------
| Branch (546:13): [True: 27, False: 31.7k]
------------------
547| 27| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 27| do { \
| | 657| 27| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27]
| | ------------------
------------------
548| 27| graph, &type, IGRAPH_ATTRIBUTE_VERTEX, vnumnames[i]));
549| 27| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (549:17): [True: 10, False: 17]
------------------
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| 27| }
553| 31.7k| }
554| 19.0k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(vstrnames) / sizeof(vstrnames[0])); i++) {
------------------
| Branch (554:30): [True: 15.8k, False: 3.17k]
------------------
555| 15.8k| igraph_attribute_type_t type;
556| 15.8k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vstrnames[i])) {
------------------
| Branch (556:13): [True: 42, False: 15.8k]
------------------
557| 42| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 42| do { \
| | 657| 42| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42]
| | ------------------
------------------
558| 42| graph, &type, IGRAPH_ATTRIBUTE_VERTEX, vstrnames[i]));
559| 42| if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (559:17): [True: 36, False: 6]
------------------
560| 36| IGRAPH_CHECK(igraph_vector_int_push_back(&vx_stra, i));
------------------
| | 656| 36| do { \
| | 657| 36| igraph_error_t igraph_i_ret = (expr); \
| | 658| 36| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 36| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 36]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 36| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 36]
| | ------------------
------------------
561| 36| }
562| 42| }
563| 15.8k| }
564| |
565| | /* Write vertices */
566| 3.17k| if (write_vertex_attrs) {
------------------
| Branch (566:9): [True: 164, False: 3.01k]
------------------
567| 1.94k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (567:34): [True: 1.78k, False: 164]
------------------
568| 1.78k| igraph_int_t id = bipartite ? VECTOR(bip_index)[i] : i;
------------------
| | 60| 401|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (568:31): [True: 401, False: 1.38k]
------------------
569| |
570| | /* vertex ID */
571| 1.78k| fprintf(outstream, "%" IGRAPH_PRId, i + 1);
------------------
| | 63| 1.78k|# define IGRAPH_PRId PRId64
------------------
572| 1.78k| if (vtypes[V_ID] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 243| 1.78k|#define V_ID 0
------------------
| Branch (572:17): [True: 66, False: 1.71k]
------------------
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.71k| } else if (vtypes[V_ID] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 243| 1.71k|#define V_ID 0
------------------
| Branch (578:24): [True: 148, False: 1.57k]
------------------
579| 148| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 148| do { \
| | 657| 148| igraph_error_t igraph_i_ret = (expr); \
| | 658| 148| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 148| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 148]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 148| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 148]
| | ------------------
------------------
580| 148| graph, vnames[V_ID], igraph_vss_1(id), &strv));
581| 148| s = igraph_strvector_get(&strv, 0);
582| 148| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 148| do { \
| | 657| 148| igraph_error_t igraph_i_ret = (expr); \
| | 658| 148| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 148| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 148]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 148| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 148]
| | ------------------
------------------
583| 148| fprintf(outstream, " %s", escaped);
584| 148| IGRAPH_FREE(escaped);
------------------
| | 36| 148|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
585| 1.57k| } else {
586| 1.57k| fprintf(outstream, " \"%" IGRAPH_PRId "\"", id + 1);
587| 1.57k| }
588| |
589| | /* coordinates */
590| 1.78k| if (vtypes[V_X] == IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| | 244| 1.78k|#define V_X 1
------------------
| Branch (590:17): [True: 66, False: 1.71k]
------------------
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.78k| if (vtypes[V_SHAPE] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 247| 1.78k|#define V_SHAPE 4
------------------
| Branch (609:17): [True: 209, False: 1.57k]
------------------
610| 209| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_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]
| | ------------------
------------------
611| 209| graph, vnames[V_SHAPE], igraph_vss_1(id), &strv));
612| 209| s = igraph_strvector_get(&strv, 0);
613| 209| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 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]
| | ------------------
------------------
614| 209| fprintf(outstream, " %s", escaped);
615| 209| IGRAPH_FREE(escaped);
------------------
| | 36| 209|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
616| 209| }
617| |
618| | /* numeric parameters */
619| 2.10k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vx_numa); j++) {
------------------
| Branch (619:38): [True: 323, False: 1.78k]
------------------
620| 323| igraph_int_t idx = VECTOR(vx_numa)[j];
------------------
| | 60| 323|#define VECTOR(v) ((v).stor_begin)
------------------
621| 323| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 656| 323| do { \
| | 657| 323| igraph_error_t igraph_i_ret = (expr); \
| | 658| 323| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 323| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 323]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 323| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 323]
| | ------------------
------------------
622| 323| graph, vnumnames[idx], igraph_vss_1(id), &numv));
623| 323| fprintf(outstream, " %s ", vnumnames2[idx]);
624| 323| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 323|#define VECTOR(v) ((v).stor_begin)
------------------
625| 323| }
626| |
627| | /* string parameters */
628| 2.19k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vx_stra); j++) {
------------------
| Branch (628:38): [True: 409, False: 1.78k]
------------------
629| 409| igraph_int_t idx = VECTOR(vx_stra)[j];
------------------
| | 60| 409|#define VECTOR(v) ((v).stor_begin)
------------------
630| 409| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 409| do { \
| | 657| 409| igraph_error_t igraph_i_ret = (expr); \
| | 658| 409| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 409| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 409]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 409| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 409]
| | ------------------
------------------
631| 409| graph, vstrnames[idx], igraph_vss_1(id), &strv));
632| 409| s = igraph_strvector_get(&strv, 0);
633| 409| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 409| do { \
| | 657| 409| igraph_error_t igraph_i_ret = (expr); \
| | 658| 409| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 409| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 409]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 409| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 409]
| | ------------------
------------------
634| 409| fprintf(outstream, " %s %s", vstrnames2[idx], escaped);
635| 409| IGRAPH_FREE(escaped);
------------------
| | 36| 409|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
636| 409| }
637| |
638| | /* trailing newline */
639| 1.78k| fprintf(outstream, "%s", newline);
640| 1.78k| }
641| 164| }
642| |
643| | /* edges header */
644| 3.17k| if (igraph_is_directed(graph)) {
------------------
| Branch (644:9): [True: 133, False: 3.04k]
------------------
645| 133| fprintf(outstream, "*Arcs%s", newline);
646| 3.04k| } else {
647| 3.04k| fprintf(outstream, "*Edges%s", newline);
648| 3.04k| }
649| |
650| 3.17k| IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_ID));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
651| 3.17k| IGRAPH_FINALLY(igraph_es_destroy, &es);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
652| 3.17k| IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
------------------
| | 656| 3.17k| do { \
| | 657| 3.17k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.17k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.17k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.17k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.17k]
| | ------------------
------------------
653| 3.17k| IGRAPH_FINALLY(igraph_eit_destroy, &eit);
------------------
| | 603| 3.17k| do { \
| | 604| 3.17k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.17k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.17k| * incorrect destructor function with the pointer */ \
| | 607| 3.17k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.17k]
| | ------------------
| | 608| 3.17k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.17k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.17k]
| | ------------------
------------------
654| |
655| | /* Check edge attributes */
656| | /* TODO: refactor and simplify since only "weight" is relevant */
657| 6.35k| for (igraph_int_t i = 0; i < E_LAST; i++) {
------------------
| | 266| 6.35k|#define E_LAST 1
------------------
| Branch (657:30): [True: 3.17k, False: 3.17k]
------------------
658| 3.17k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, enames[i])) {
------------------
| Branch (658:13): [True: 230, False: 2.94k]
------------------
659| 230| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 230| do { \
| | 657| 230| igraph_error_t igraph_i_ret = (expr); \
| | 658| 230| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 230| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 230]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 230| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 230]
| | ------------------
------------------
660| 230| graph, &etypes[i], IGRAPH_ATTRIBUTE_EDGE, enames[i]));
661| 2.94k| } else {
662| 2.94k| etypes[i] = (igraph_attribute_type_t) -1;
663| 2.94k| }
664| 3.17k| }
665| 47.6k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(enumnames) / sizeof(enumnames[0])); i++) {
------------------
| Branch (665:30): [True: 44.5k, False: 3.17k]
------------------
666| 44.5k| igraph_attribute_type_t type;
667| 44.5k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, enumnames[i])) {
------------------
| Branch (667:13): [True: 21, False: 44.4k]
------------------
668| 21| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 21| do { \
| | 657| 21| igraph_error_t igraph_i_ret = (expr); \
| | 658| 21| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 21| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 21]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 21]
| | ------------------
------------------
669| 21| graph, &type, IGRAPH_ATTRIBUTE_EDGE, enumnames[i]));
670| 21| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (670:17): [True: 15, False: 6]
------------------
671| 15| IGRAPH_CHECK(igraph_vector_int_push_back(&ex_numa, i));
------------------
| | 656| 15| do { \
| | 657| 15| igraph_error_t igraph_i_ret = (expr); \
| | 658| 15| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 15| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15]
| | ------------------
------------------
672| 15| }
673| 21| }
674| 44.5k| }
675| 22.2k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(estrnames) / sizeof(estrnames[0])); i++) {
------------------
| Branch (675:30): [True: 19.0k, False: 3.17k]
------------------
676| 19.0k| igraph_attribute_type_t type;
677| 19.0k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, estrnames[i])) {
------------------
| Branch (677:13): [True: 136, False: 18.9k]
------------------
678| 136| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 136| do { \
| | 657| 136| igraph_error_t igraph_i_ret = (expr); \
| | 658| 136| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 136| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 136]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 136| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 136]
| | ------------------
------------------
679| 136| graph, &type, IGRAPH_ATTRIBUTE_EDGE, estrnames[i]));
680| 136| if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (680:17): [True: 115, False: 21]
------------------
681| 115| IGRAPH_CHECK(igraph_vector_int_push_back(&ex_stra, i));
------------------
| | 656| 115| do { \
| | 657| 115| igraph_error_t igraph_i_ret = (expr); \
| | 658| 115| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 115| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 115]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 115| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 115]
| | ------------------
------------------
682| 115| }
683| 136| }
684| 19.0k| }
685| |
686| 355k| for (igraph_int_t i = 0; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit), i++) {
------------------
| | 371| 355k|#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| 352k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (686:30): [True: 352k, False: 3.17k]
------------------
687| 352k| igraph_int_t edge = IGRAPH_EIT_GET(eit);
------------------
| | 405| 352k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 352k, False: 0]
| | ------------------
| | 406| 352k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
688| 352k| igraph_int_t from, to;
689| |
690| 352k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 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]
| | ------------------
------------------
691| 352k| if (bipartite) {
------------------
| Branch (691:13): [True: 372, False: 352k]
------------------
692| 372| from = VECTOR(bip_index2)[from];
------------------
| | 60| 372|#define VECTOR(v) ((v).stor_begin)
------------------
693| 372| to = VECTOR(bip_index2)[to];
------------------
| | 60| 372|#define VECTOR(v) ((v).stor_begin)
------------------
694| 372| }
695| 352k| fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId , from + 1, to + 1);
------------------
| | 63| 352k|# define IGRAPH_PRId PRId64
------------------
696| |
697| | /* Weights */
698| 352k| if (etypes[E_WEIGHT] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 265| 352k|#define E_WEIGHT 0
------------------
| Branch (698:13): [True: 90.9k, False: 261k]
------------------
699| 90.9k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 90.9k| do { \
| | 657| 90.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 90.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 90.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 90.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| 90.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 90.9k]
| | ------------------
------------------
700| 90.9k| graph, enames[E_WEIGHT], igraph_ess_1(edge), &numv));
701| 90.9k| fputc(' ', outstream);
702| 90.9k| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 90.9k|#define VECTOR(v) ((v).stor_begin)
------------------
703| 90.9k| }
704| |
705| | /* numeric parameters */
706| 352k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&ex_numa); j++) {
------------------
| Branch (706:34): [True: 217, False: 352k]
------------------
707| 217| igraph_int_t idx = VECTOR(ex_numa)[j];
------------------
| | 60| 217|#define VECTOR(v) ((v).stor_begin)
------------------
708| 217| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 217| do { \
| | 657| 217| igraph_error_t igraph_i_ret = (expr); \
| | 658| 217| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 217| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 217]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 217| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 217]
| | ------------------
------------------
709| 217| graph, enumnames[idx], igraph_ess_1(edge), &numv));
710| 217| fprintf(outstream, " %s ", enumnames2[idx]);
711| 217| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 217|#define VECTOR(v) ((v).stor_begin)
------------------
712| 217| }
713| |
714| | /* string parameters */
715| 355k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&ex_stra); j++) {
------------------
| Branch (715:34): [True: 2.81k, False: 352k]
------------------
716| 2.81k| igraph_int_t idx = VECTOR(ex_stra)[j];
------------------
| | 60| 2.81k|#define VECTOR(v) ((v).stor_begin)
------------------
717| 2.81k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(
------------------
| | 656| 2.81k| do { \
| | 657| 2.81k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.81k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.81k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.81k]
| | ------------------
------------------
718| 2.81k| graph, estrnames[idx], igraph_ess_1(edge), &strv));
719| 2.81k| s = igraph_strvector_get(&strv, 0);
720| 2.81k| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 2.81k| do { \
| | 657| 2.81k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.81k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.81k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.81k]
| | ------------------
------------------
721| 2.81k| fprintf(outstream, " %s %s", estrnames2[idx], escaped);
722| 2.81k| IGRAPH_FREE(escaped);
------------------
| | 36| 2.81k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
723| 2.81k| }
724| |
725| | /* trailing newline */
726| 352k| fprintf(outstream, "%s", newline);
727| 352k| }
728| |
729| 3.17k| igraph_eit_destroy(&eit);
730| 3.17k| igraph_es_destroy(&es);
731| 3.17k| IGRAPH_FINALLY_CLEAN(2);
732| |
733| 3.17k| if (bipartite) {
------------------
| Branch (733:9): [True: 29, False: 3.15k]
------------------
734| 29| igraph_vector_int_destroy(&bip_index2);
735| 29| igraph_vector_int_destroy(&bip_index);
736| 29| IGRAPH_FINALLY_CLEAN(2);
737| 29| }
738| |
739| 3.17k| igraph_vector_int_destroy(&ex_numa);
740| 3.17k| igraph_vector_int_destroy(&ex_stra);
741| 3.17k| igraph_vector_int_destroy(&vx_numa);
742| 3.17k| igraph_vector_int_destroy(&vx_stra);
743| 3.17k| igraph_strvector_destroy(&strv);
744| 3.17k| igraph_vector_destroy(&numv);
745| 3.17k| IGRAPH_FINALLY_CLEAN(6);
746| 3.17k| return IGRAPH_SUCCESS;
747| 3.17k|}
pajek.c:pajek_escape:
270| 3.57k|static igraph_error_t pajek_escape(const char* src, char** dest) {
271| 3.57k| igraph_int_t destlen = 0;
272| 3.57k| igraph_bool_t need_escape = false;
273| |
274| | /* Determine whether the string contains characters to be escaped */
275| 3.57k| const char *s;
276| 3.57k| char *d;
277| 29.8M| for (s = src; *s; s++, destlen++) {
------------------
| Branch (277:19): [True: 29.8M, False: 3.57k]
------------------
278| 29.8M| if (*s == '\n' || *s == '\r') {
------------------
| Branch (278:13): [True: 1.28M, False: 28.5M]
| Branch (278:27): [True: 350, False: 28.5M]
------------------
279| 1.28M| need_escape = true;
280| 1.28M| destlen++;
281| 28.5M| } else if (*s == '"') {
------------------
| Branch (281:20): [True: 5.71M, False: 22.8M]
------------------
282| 5.71M| need_escape = true;
283| 5.71M| destlen += 4;
284| 22.8M| } else if (!isalnum(*s)) {
------------------
| Branch (284:20): [True: 13.8M, False: 9.06M]
------------------
285| 13.8M| need_escape = true;
286| 13.8M| }
287| 29.8M| }
288| |
289| 3.57k| if (!need_escape) {
------------------
| Branch (289:9): [True: 728, False: 2.84k]
------------------
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.84k| *dest = IGRAPH_CALLOC(destlen + 3, char);
------------------
| | 33| 2.84k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 5.69k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 2.84k, False: 0]
| | | | | Branch (31:24): [True: 2.84k, False: 0]
| | | | | Branch (31:66): [True: 2.84k, False: 0]
| | | | ------------------
| | ------------------
------------------
307| 2.84k| CHECK_OOM_WP(*dest);
------------------
| | 44| 2.84k|#define CHECK_OOM_WP(p) IGRAPH_CHECK_OOM((p), "Not enough memory to write Pajek format.")
| | ------------------
| | | | 709| 2.84k| do { \
| | | | 710| 2.84k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | | | ------------------
| | | | | | 612| 2.84k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 2.84k]
| | | | | | ------------------
| | | | ------------------
| | | | 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.84k| } while (0)
| | | | ------------------
| | | | | Branch (713:14): [Folded, False: 2.84k]
| | | | ------------------
| | ------------------
------------------
308| |
309| 2.84k| d = *dest;
310| 2.84k| *d = '"'; d++;
311| |
312| 28.8M| for (s = src; *s; s++, d++) {
------------------
| Branch (312:19): [True: 28.8M, False: 2.84k]
------------------
313| 28.8M| switch (*s) {
314| | /* Encode quotation marks as ", as they would otherwise signify
315| | the end/beginning of a string. */
316| 5.71M| case '"':
------------------
| Branch (316:9): [True: 5.71M, False: 23.1M]
------------------
317| 5.71M| 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| 1.28M| case '\n':
------------------
| Branch (321:9): [True: 1.28M, False: 27.5M]
------------------
322| 1.28M| case '\r':
------------------
| Branch (322:9): [True: 350, False: 28.8M]
------------------
323| 1.28M| *d = '\\'; d++;
324| 1.28M| *d = 'n';
325| 1.28M| break;
326| 21.8M| default:
------------------
| Branch (326:9): [True: 21.8M, False: 6.99M]
------------------
327| 21.8M| *d = *s;
328| 28.8M| }
329| 28.8M| }
330| 2.84k| *d = '"'; d++; *d = 0;
331| |
332| 2.84k| return IGRAPH_SUCCESS;
333| 2.84k|}
igraph_i_trim_whitespace:
33| 18.5k|void igraph_i_trim_whitespace(const char *str, size_t str_len, const char **res, size_t *res_len) {
34| 18.5k| const char *beg = str, *end = str + str_len;
35| 41.0k| while (beg < end && isspace(beg[0]) ) beg++;
------------------
| Branch (35:12): [True: 40.4k, False: 633]
| Branch (35:25): [True: 22.5k, False: 17.9k]
------------------
36| 20.0k| while (end > beg && isspace(end[-1])) end--;
------------------
| Branch (36:12): [True: 19.4k, False: 633]
| Branch (36:25): [True: 1.52k, False: 17.9k]
------------------
37| 18.5k| *res = beg;
38| 18.5k| *res_len = end - beg;
39| 18.5k|}
igraph_i_parse_integer:
52| 817|igraph_error_t igraph_i_parse_integer(const char *str, size_t length, igraph_int_t *value) {
53| 817| char buffer[128];
54| 817| char *tmp, *end;
55| 817| char last_char;
56| 817| igraph_bool_t out_of_range, dynamic_alloc;
57| 817| long long val;
58| |
59| 817| if (length == 0) {
------------------
| Branch (59:9): [True: 0, False: 817]
------------------
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| 817| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]);
64| |
65| 817| if (dynamic_alloc) {
------------------
| Branch (65:9): [True: 18, False: 799]
------------------
66| 18| tmp = IGRAPH_CALLOC(length+1, char);
------------------
| | 33| 18|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 36| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 18, False: 0]
| | | | | Branch (31:24): [True: 18, False: 0]
| | | | | Branch (31:66): [True: 18, False: 0]
| | | | ------------------
| | ------------------
------------------
67| 18| IGRAPH_CHECK_OOM(tmp, "Failed to parse integer.");
------------------
| | 709| 18| do { \
| | 710| 18| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 18| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 18]
| | | | ------------------
| | ------------------
| | 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| 18| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 18]
| | ------------------
------------------
68| 799| } else {
69| 799| tmp = buffer;
70| 799| }
71| |
72| 817| strncpy(tmp, str, length);
73| 817| 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| 817| errno = 0;
79| 817| val = strtoll(tmp, &end, 10);
80| 817| out_of_range = errno == ERANGE;
81| 817| *value = (igraph_int_t) val;
82| 817| last_char = *end;
83| 817| if (*value != val) {
------------------
| Branch (83:9): [True: 0, False: 817]
------------------
84| 0| out_of_range = true;
85| 0| }
86| |
87| | /* Free memory before raising any errors. */
88| 817| if (dynamic_alloc) {
------------------
| Branch (88:9): [True: 18, False: 799]
------------------
89| 18| IGRAPH_FREE(tmp);
------------------
| | 36| 18|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
90| 18| }
91| |
92| 817| if (out_of_range) {
------------------
| Branch (92:9): [True: 1, False: 816]
------------------
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| 816| if (last_char) {
------------------
| Branch (97:9): [True: 26, False: 790]
------------------
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| 790| return IGRAPH_SUCCESS;
102| 816|}
igraph_i_parse_real:
113| 945k|igraph_error_t igraph_i_parse_real(const char *str, size_t length, igraph_real_t *value) {
114| 945k| char buffer[128];
115| 945k| char *tmp, *end;
116| 945k| char last_char;
117| 945k| igraph_bool_t out_of_range, dynamic_alloc;
118| |
119| 945k| if (length == 0) {
------------------
| Branch (119:9): [True: 0, False: 945k]
------------------
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| 945k| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]);
124| |
125| 945k| if (dynamic_alloc) {
------------------
| Branch (125:9): [True: 206, False: 945k]
------------------
126| 206| tmp = IGRAPH_CALLOC(length+1, char);
------------------
| | 33| 206|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 412| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 206, False: 0]
| | | | | Branch (31:24): [True: 206, False: 0]
| | | | | Branch (31:66): [True: 206, False: 0]
| | | | ------------------
| | ------------------
------------------
127| 206| IGRAPH_CHECK_OOM(tmp, "Failed to parse real number.");
------------------
| | 709| 206| do { \
| | 710| 206| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 206| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 206]
| | | | ------------------
| | ------------------
| | 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| 206| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 206]
| | ------------------
------------------
128| 945k| } else {
129| 945k| tmp = buffer;
130| 945k| }
131| |
132| 945k| strncpy(tmp, str, length);
133| 945k| tmp[length]='\0';
134| |
135| 945k| errno = 0;
136| 945k| *value = strtod(tmp, &end);
137| 945k| out_of_range = errno == ERANGE; /* This does not trigger when reading +-Inf. */
138| 945k| last_char = *end;
139| |
140| | /* Free memory before raising any errors. */
141| 945k| if (dynamic_alloc) {
------------------
| Branch (141:9): [True: 206, False: 945k]
------------------
142| 206| IGRAPH_FREE(tmp);
------------------
| | 36| 206|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
143| 206| }
144| |
145| 945k| if (out_of_range) {
------------------
| Branch (145:9): [True: 2, False: 945k]
------------------
146| 2| IGRAPH_ERROR("Failed to parse real number.", *value > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW);
------------------
| | 426| 2| do { \
| | 427| 4| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | ------------------
| | | Branch (427:63): [True: 1, False: 1]
| | ------------------
| | 428| 4| return igraph_errno ; \
| | ------------------
| | | Branch (428:16): [True: 1, False: 1]
| | ------------------
| | 429| 2| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
147| 2| }
148| |
149| | /* Did we parse to the end of the string? */
150| 945k| if (last_char) {
------------------
| Branch (150:9): [True: 16, False: 945k]
------------------
151| 16| IGRAPH_ERRORF("Unexpected character '%c' while parsing real number.", IGRAPH_PARSEERROR, last_char);
------------------
| | 464| 16| do { \
| | 465| 16| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 16| igraph_errno, __VA_ARGS__) ; \
| | 467| 16| return igraph_errno; \
| | 468| 16| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
152| 16| }
153| |
154| 945k| return IGRAPH_SUCCESS;
155| 945k|}
igraph_i_is_real_representable_as_integer:
111| 758k|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| 758k| const igraph_real_t int_max_plus_1 = 2.0 * (IGRAPH_INTEGER_MAX / 2 + 1);
------------------
| | 72| 758k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
123| 758k| const igraph_real_t int_min = (igraph_real_t) IGRAPH_INTEGER_MIN;
------------------
| | 73| 758k|# define IGRAPH_INTEGER_MIN INT64_MIN
------------------
124| 758k| if (IGRAPH_LIKELY(int_min <= value && value < int_max_plus_1)) {
------------------
| | 613| 1.51M| #define IGRAPH_LIKELY(a) __builtin_expect(!!(a), 1)
| | ------------------
| | | Branch (613:32): [True: 758k, False: 222]
| | | Branch (613:52): [True: 758k, False: 194]
| | | Branch (613:52): [True: 758k, False: 28]
| | ------------------
------------------
125| 758k| return true;
126| 758k| } else {
127| | return false;
128| 222| }
129| 758k|}