igraph_gml_yylex:
1027| 2.83M|{
1028| 2.83M| yy_state_type yy_current_state;
1029| 2.83M| char *yy_cp, *yy_bp;
1030| 2.83M| int yy_act;
1031| 2.83M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1032| |
1033| 2.83M| yylval = yylval_param;
------------------
| | 837| 2.83M| # define yylval yyg->yylval_r
------------------
1034| |
1035| 2.83M| yylloc = yylloc_param;
------------------
| | 839| 2.83M| # define yylloc yyg->yylloc_r
------------------
1036| |
1037| 2.83M| if ( !yyg->yy_init )
------------------
| Branch (1037:7): [True: 3.57k, False: 2.83M]
------------------
1038| 3.57k| {
1039| 3.57k| yyg->yy_init = 1;
1040| |
1041| |#ifdef YY_USER_INIT
1042| | YY_USER_INIT;
1043| |#endif
1044| |
1045| 3.57k| if ( ! yyg->yy_start )
------------------
| Branch (1045:8): [True: 3.57k, False: 0]
------------------
1046| 3.57k| yyg->yy_start = 1; /* first start state */
1047| |
1048| 3.57k| if ( ! yyin )
------------------
| | 356| 3.57k|#define yyin yyg->yyin_r
------------------
| Branch (1048:8): [True: 0, False: 3.57k]
------------------
1049| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1050| |
1051| 3.57k| if ( ! yyout )
------------------
| | 357| 3.57k|#define yyout yyg->yyout_r
------------------
| Branch (1051:8): [True: 3.57k, False: 0]
------------------
1052| 3.57k| yyout = stdout;
------------------
| | 357| 3.57k|#define yyout yyg->yyout_r
------------------
1053| |
1054| 3.57k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.57k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.57k]
| | ------------------
| | 522| 3.57k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.57k| : NULL)
------------------
| Branch (1054:8): [True: 3.57k, False: 0]
------------------
1055| 3.57k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.57k|#define yyensure_buffer_stack igraph_gml_yyensure_buffer_stack
------------------
1056| 3.57k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1057| 3.57k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.57k|#define yy_create_buffer igraph_gml_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.57k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.57k|#define YY_BUF_SIZE 16384
------------------
1058| 3.57k| }
1059| |
1060| 3.57k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.57k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1061| 3.57k| }
1062| |
1063| 2.83M| {
1064| 2.83M|#line 80 "/src/igraph/src/io/gml-lexer.l"
1065| |
1066| |
1067| 2.83M|#line 1068 "/src/igraph/build/src/io/parsers/gml-lexer.c"
1068| |
1069| 7.53M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1069:23): [True: 7.53M, Folded]
------------------
1070| 7.53M| {
1071| 7.53M| yy_cp = yyg->yy_c_buf_p;
1072| |
1073| | /* Support of yytext. */
1074| 7.53M| *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| 7.53M| yy_bp = yy_cp;
1080| |
1081| 7.53M| yy_current_state = yyg->yy_start;
1082| 7.53M| yy_current_state += YY_AT_BOL();
------------------
| | 569| 7.53M|#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
| | ------------------
| | | | 527| 7.53M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1083| 7.56M|yy_match:
1084| 7.56M| do
1085| 211M| {
1086| 211M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 211M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1087| 211M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1087:9): [True: 33.3M, False: 177M]
------------------
1088| 33.3M| {
1089| 33.3M| yyg->yy_last_accepting_state = yy_current_state;
1090| 33.3M| yyg->yy_last_accepting_cpos = yy_cp;
1091| 33.3M| }
1092| 416M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1092:12): [True: 205M, False: 211M]
------------------
1093| 205M| {
1094| 205M| yy_current_state = (int) yy_def[yy_current_state];
1095| 205M| if ( yy_current_state >= 43 )
------------------
| Branch (1095:10): [True: 194M, False: 11.3M]
------------------
1096| 194M| yy_c = yy_meta[yy_c];
1097| 205M| }
1098| 211M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1099| 211M| ++yy_cp;
1100| 211M| }
1101| 211M| while ( yy_base[yy_current_state] != 85 );
------------------
| Branch (1101:11): [True: 203M, False: 7.56M]
------------------
1102| |
1103| 7.57M|yy_find_action:
1104| 7.57M| yy_act = yy_accept[yy_current_state];
1105| 7.57M| if ( yy_act == 0 )
------------------
| Branch (1105:8): [True: 6.60M, False: 962k]
------------------
1106| 6.60M| { /* have to back up */
1107| 6.60M| yy_cp = yyg->yy_last_accepting_cpos;
1108| 6.60M| yy_current_state = yyg->yy_last_accepting_state;
1109| 6.60M| yy_act = yy_accept[yy_current_state];
1110| 6.60M| }
1111| |
1112| 7.57M| YY_DO_BEFORE_ACTION;
------------------
| | 590| 7.57M| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 7.57M|#define yytext_ptr yytext_r
| | ------------------
| | 591| 7.57M| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 7.57M|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 7.57M| yyg->yy_hold_char = *yy_cp; \
| | 593| 7.57M| *yy_cp = '\0'; \
| | 594| 7.57M| yyg->yy_c_buf_p = yy_cp;
------------------
1113| |
1114| 7.57M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 15.1M|#define YY_END_OF_BUFFER 12
------------------
| Branch (1114:8): [True: 7.53M, False: 36.1k]
| Branch (1114:38): [True: 2.21M, False: 5.31M]
------------------
1115| 2.21M| {
1116| 2.21M| int yyl;
1117| 175M| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 175M|#define yyleng yyg->yyleng_r
------------------
| Branch (1117:19): [True: 172M, False: 2.21M]
------------------
1118| 172M| if ( yytext[yyl] == '\n' )
------------------
| | 360| 172M|#define yytext yyg->yytext_r
------------------
| Branch (1118:10): [True: 13.1M, False: 159M]
------------------
1119| |
1120| 13.1M| do{ yylineno++;
------------------
| | 361| 13.1M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 13.1M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1121| 13.1M| yycolumn=0;
------------------
| | 362| 13.1M|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 13.1M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1122| 13.1M| }while(0)
------------------
| Branch (1122:12): [Folded, False: 13.1M]
------------------
1123| 2.21M|;
1124| 2.21M| }
1125| |
1126| 7.57M|do_action: /* This label is used only to access EOF actions. */
1127| |
1128| 7.57M| switch ( yy_act )
1129| 7.57M| { /* beginning of action switch */
1130| 0| case 0: /* must back up */
------------------
| Branch (1130:4): [True: 0, False: 7.57M]
------------------
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: 7.57M]
------------------
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| 323k|case 2:
------------------
| Branch (1142:1): [True: 323k, False: 7.25M]
------------------
1143| |/* rule 2 can match eol */
1144| 323k|YY_RULE_SETUP
------------------
| | 1019| 323k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 323k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 323k, False: 0]
| | ------------------
| | 1020| 323k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 323k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 323k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 323k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 323k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 323k| YY_USER_ACTION
| | ------------------
| | | | 764| 323k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 323k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 323k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 323k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1145| 323k|#line 84 "/src/igraph/src/io/gml-lexer.l"
1146| 323k|{ BEGIN(INITIAL); return STRING; }
------------------
| | 369| 323k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return STRING; }
------------------
| | 780| 323k|#define INITIAL 0
------------------
1147| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1148| 0|case 3:
------------------
| Branch (1148:1): [True: 0, False: 7.57M]
------------------
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| 615k|case 4:
------------------
| Branch (1153:1): [True: 615k, False: 6.95M]
------------------
1154| 615k|YY_RULE_SETUP
------------------
| | 1019| 615k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 615k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 615k, False: 0]
| | ------------------
| | 1020| 615k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 615k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 615k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 615k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 615k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 615k| YY_USER_ACTION
| | ------------------
| | | | 764| 615k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 615k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 615k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 615k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1155| 615k|#line 86 "/src/igraph/src/io/gml-lexer.l"
1156| 615k|{ BEGIN(INITIAL); return NUM; }
------------------
| | 369| 615k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NUM; }
------------------
| | 780| 615k|#define INITIAL 0
------------------
1157| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1158| 1.25M|case 5:
------------------
| Branch (1158:1): [True: 1.25M, False: 6.31M]
------------------
1159| 1.25M|YY_RULE_SETUP
------------------
| | 1019| 1.25M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 1.25M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 1.25M, False: 0]
| | ------------------
| | 1020| 1.25M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 1.25M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 1.25M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 1.25M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 1.25M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 1.25M| YY_USER_ACTION
| | ------------------
| | | | 764| 1.25M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 1.25M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 1.25M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 1.25M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1160| 1.25M|#line 87 "/src/igraph/src/io/gml-lexer.l"
1161| 1.25M|{ BEGIN(VALUE); return KEYWORD; }
------------------
| | 369| 1.25M|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(VALUE); return KEYWORD; }
------------------
| | 781| 1.25M|#define VALUE 1
------------------
1162| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1163| 317k|case 6:
------------------
| Branch (1163:1): [True: 317k, False: 7.25M]
------------------
1164| 317k|YY_RULE_SETUP
------------------
| | 1019| 317k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 317k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 317k, False: 0]
| | ------------------
| | 1020| 317k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 317k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 317k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 317k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 317k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 317k| YY_USER_ACTION
| | ------------------
| | | | 764| 317k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 317k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 317k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 317k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1165| 317k|#line 88 "/src/igraph/src/io/gml-lexer.l"
1166| 317k|{
1167| 317k| BEGIN(INITIAL);
------------------
| | 369| 317k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
BEGIN(INITIAL);
------------------
| | 780| 317k|#define INITIAL 0
------------------
1168| 317k| yyextra->depth++;
------------------
| | 358| 317k|#define yyextra yyg->yyextra_r
------------------
1169| 317k| if (yyextra->depth >= 32) {
------------------
| | 358| 317k|#define yyextra yyg->yyextra_r
------------------
| Branch (1169:31): [True: 0, False: 317k]
------------------
1170| 0| return ERROR;
1171| 317k| } else {
1172| 317k| return LISTOPEN;
1173| 317k| }
1174| 317k| }
1175| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1176| 317k|case 7:
------------------
| Branch (1176:1): [True: 317k, False: 7.25M]
------------------
1177| 317k|YY_RULE_SETUP
------------------
| | 1019| 317k| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 317k|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 317k, False: 0]
| | ------------------
| | 1020| 317k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 317k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 317k| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 317k|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 317k|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 317k| YY_USER_ACTION
| | ------------------
| | | | 764| 317k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 317k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 317k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 317k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1178| 317k|#line 97 "/src/igraph/src/io/gml-lexer.l"
1179| 317k|{
1180| 317k| yyextra->depth--;
------------------
| | 358| 317k|#define yyextra yyg->yyextra_r
------------------
1181| 317k| return LISTCLOSE;
1182| 317k| }
1183| 0| YY_BREAK
------------------
| | 1015| 0|#define YY_BREAK /*LINTED*/break;
------------------
1184| 2.81M|case 8:
------------------
| Branch (1184:1): [True: 2.81M, False: 4.76M]
------------------
1185| 2.81M|YY_RULE_SETUP
------------------
| | 1019| 2.81M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 2.81M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 2.81M, False: 0]
| | ------------------
| | 1020| 2.81M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 2.81M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 2.81M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 2.81M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 2.81M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 2.81M| YY_USER_ACTION
| | ------------------
| | | | 764| 2.81M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 2.81M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 2.81M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 2.81M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1186| 2.81M|#line 101 "/src/igraph/src/io/gml-lexer.l"
1187| 2.81M|{ /* other whitespace ignored */ }
1188| 2.81M| YY_BREAK
------------------
| | 1015| 2.81M|#define YY_BREAK /*LINTED*/break;
------------------
1189| 1.89M|case 9:
------------------
| Branch (1189:1): [True: 1.89M, False: 5.68M]
------------------
1190| |/* rule 9 can match eol */
1191| 1.89M|YY_RULE_SETUP
------------------
| | 1019| 1.89M| if ( yyleng > 0 ) \
| | ------------------
| | | | 359| 1.89M|#define yyleng yyg->yyleng_r
| | ------------------
| | | Branch (1019:7): [True: 1.89M, False: 0]
| | ------------------
| | 1020| 1.89M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
| | ------------------
| | | | 527| 1.89M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 1021| 1.89M| (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 360| 1.89M|#define yytext yyg->yytext_r
| | ------------------
| | (yytext[yyleng - 1] == '\n'); \
| | ------------------
| | | | 359| 1.89M|#define yyleng yyg->yyleng_r
| | ------------------
| | 1022| 1.89M| YY_USER_ACTION
| | ------------------
| | | | 764| 1.89M|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 839| 1.89M| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 1.89M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 1.89M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1192| 1.89M|#line 102 "/src/igraph/src/io/gml-lexer.l"
1193| 1.89M|{ yy_set_bol(true); /* set "beginning of line" even after \r */ }
------------------
| | 561| 1.89M| { \
| | 562| 1.89M| if ( ! YY_CURRENT_BUFFER ){\
| | ------------------
| | | | 521| 1.89M|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | | | ------------------
| | | | | Branch (521:29): [True: 1.89M, False: 0]
| | | | ------------------
| | | | 522| 1.89M| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | | | 523| 1.89M| : NULL)
| | ------------------
| | | Branch (562:7): [True: 0, False: 1.89M]
| | ------------------
| | 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| 1.89M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
| | ------------------
| | | | 527| 1.89M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | 568| 1.89M| }
------------------
1194| 1.89M| YY_BREAK
------------------
| | 1015| 1.89M|#define YY_BREAK /*LINTED*/break;
------------------
1195| 0|case 10:
------------------
| Branch (1195:1): [True: 0, False: 7.57M]
------------------
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: 7.57M]
------------------
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.57k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.57k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.57k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
| Branch (1206:1): [True: 3.57k, False: 7.57M]
------------------
1207| 3.57k|case YY_STATE_EOF(VALUE):
------------------
| | 377| 3.57k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.57k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
| Branch (1207:1): [True: 0, False: 7.57M]
------------------
1208| 3.57k| yyterminate();
------------------
| | 978| 3.57k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.57k|#define YY_NULL 0
| | ------------------
------------------
1209| |
1210| 36.1k| case YY_END_OF_BUFFER:
------------------
| | 596| 36.1k|#define YY_END_OF_BUFFER 12
------------------
| Branch (1210:2): [True: 36.1k, False: 7.53M]
------------------
1211| 36.1k| {
1212| | /* Amount of text matched not including the EOB char. */
1213| 36.1k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 36.1k|#define yytext_ptr yytext_r
------------------
1214| |
1215| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1216| 36.1k| *yy_cp = yyg->yy_hold_char;
1217| 36.1k| YY_RESTORE_YY_MORE_OFFSET
1218| |
1219| 36.1k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 498| 36.1k|#define YY_BUFFER_NEW 0
------------------
| Branch (1219:8): [True: 3.57k, False: 32.5k]
------------------
1220| 3.57k| {
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.57k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1231| 3.57k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.57k|#define yyin yyg->yyin_r
------------------
1232| 3.57k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.57k|#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.57k|#define YY_BUFFER_NORMAL 1
------------------
1233| 3.57k| }
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| 36.1k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1242:8): [True: 0, False: 36.1k]
------------------
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| 36.1k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1278:17): [True: 36.1k, False: 0]
------------------
1279| 36.1k| {
1280| 3.57k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.57k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1280:4): [True: 3.57k, False: 32.5k]
------------------
1281| 3.57k| {
1282| 3.57k| yyg->yy_did_buffer_switch_on_eof = 0;
1283| |
1284| 3.57k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.57k|#define yywrap igraph_gml_yywrap
| | ------------------
| | | | 573| 3.57k|#define igraph_gml_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:38): [True: 3.57k, Folded]
| | | | ------------------
| | ------------------
------------------
1285| 3.57k| {
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.57k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.57k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 3.57k|#define YY_MORE_ADJ 0
------------------
1296| |
1297| 3.57k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.57k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.57k|#define YY_END_OF_BUFFER 12
| | ------------------
------------------
1298| 3.57k| goto do_action;
1299| 3.57k| }
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.57k| }
1308| |
1309| 28.9k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 28.9k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1309:4): [True: 28.9k, False: 7.15k]
------------------
1310| 28.9k| yyg->yy_c_buf_p =
1311| 28.9k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 28.9k|#define yytext_ptr yytext_r
------------------
1312| |
1313| 28.9k| yy_current_state = yy_get_previous_state( yyscanner );
1314| |
1315| 28.9k| yy_cp = yyg->yy_c_buf_p;
1316| 28.9k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 28.9k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 28.9k|#define YY_MORE_ADJ 0
------------------
1317| 28.9k| goto yy_match;
1318| |
1319| 3.57k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 3.57k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1319:4): [True: 3.57k, False: 32.5k]
------------------
1320| 3.57k| yyg->yy_c_buf_p =
1321| 3.57k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 3.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1322| |
1323| 3.57k| yy_current_state = yy_get_previous_state( yyscanner );
1324| |
1325| 3.57k| yy_cp = yyg->yy_c_buf_p;
1326| 3.57k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.57k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 712| 3.57k|#define YY_MORE_ADJ 0
------------------
1327| 3.57k| goto yy_find_action;
1328| 36.1k| }
1329| 0| break;
1330| 36.1k| }
1331| |
1332| 0| default:
------------------
| Branch (1332:2): [True: 0, False: 7.57M]
------------------
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| 7.57M| "fatal flex scanner internal error--no action found" );
1335| 7.57M| } /* end of action switch */
1336| 7.57M| } /* end of scanning one token */
1337| 2.83M| } /* end of user's declarations */
1338| 2.83M|} /* end of yylex */
igraph_gml_yyrestart:
1638| 3.57k|{
1639| 3.57k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1640| |
1641| 3.57k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.57k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.57k, False: 0]
| | ------------------
| | 522| 3.57k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.57k| : NULL)
------------------
| Branch (1641:7): [True: 0, False: 3.57k]
------------------
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.57k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.57k|#define yy_init_buffer igraph_gml_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.57k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.57k, False: 0]
| | ------------------
| | 522| 3.57k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.57k| : NULL)
------------------
1648| 3.57k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.57k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1649| 3.57k|}
igraph_gml_yy_create_buffer:
1703| 3.57k|{
1704| 3.57k| YY_BUFFER_STATE b;
1705| |
1706| 3.57k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.57k|#define yyalloc igraph_gml_yyalloc
------------------
1707| 3.57k| if ( ! b )
------------------
| Branch (1707:7): [True: 0, False: 3.57k]
------------------
1708| 3.57k| 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.57k| 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.57k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.57k|#define yyalloc igraph_gml_yyalloc
------------------
1716| 3.57k| if ( ! b->yy_ch_buf )
------------------
| Branch (1716:7): [True: 0, False: 3.57k]
------------------
1717| 3.57k| 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.57k| b->yy_is_our_buffer = 1;
1720| |
1721| 3.57k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.57k|#define yy_init_buffer igraph_gml_yy_init_buffer
------------------
1722| |
1723| 3.57k| return b;
1724| 3.57k|}
igraph_gml_yy_delete_buffer:
1731| 3.57k|{
1732| 3.57k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1733| |
1734| 3.57k| if ( ! b )
------------------
| Branch (1734:7): [True: 0, False: 3.57k]
------------------
1735| 0| return;
1736| |
1737| 3.57k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.57k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.57k, False: 0]
| | ------------------
| | 522| 3.57k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.57k| : NULL)
------------------
| Branch (1737:7): [True: 3.57k, False: 0]
------------------
1738| 3.57k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1739| |
1740| 3.57k| if ( b->yy_is_our_buffer )
------------------
| Branch (1740:7): [True: 3.57k, False: 0]
------------------
1741| 3.57k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.57k|#define yyfree igraph_gml_yyfree
------------------
1742| |
1743| 3.57k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.57k|#define yyfree igraph_gml_yyfree
------------------
1744| 3.57k|}
igraph_gml_yy_flush_buffer:
1780| 7.15k|{
1781| 7.15k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1782| 7.15k| if ( ! b )
------------------
| Branch (1782:7): [True: 0, False: 7.15k]
------------------
1783| 0| return;
1784| |
1785| 7.15k| 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| 7.15k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 7.15k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1792| 7.15k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 7.15k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1793| |
1794| 7.15k| b->yy_buf_pos = &b->yy_ch_buf[0];
1795| |
1796| 7.15k| b->yy_at_bol = 1;
1797| 7.15k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 7.15k|#define YY_BUFFER_NEW 0
------------------
1798| |
1799| 7.15k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 7.15k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 7.15k, False: 0]
| | ------------------
| | 522| 7.15k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 7.15k| : NULL)
------------------
| Branch (1799:7): [True: 3.57k, False: 3.57k]
------------------
1800| 3.57k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.57k|#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
------------------
1801| 7.15k|}
igraph_gml_yypop_buffer_state:
1841| 3.57k|{
1842| 3.57k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1843| 3.57k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.57k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.57k, False: 0]
| | ------------------
| | 522| 3.57k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.57k| : NULL)
------------------
| Branch (1843:6): [True: 3.57k, False: 0]
------------------
1844| 3.57k| 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.19M|{
2079| 2.19M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2080| 2.19M| return yyleng;
------------------
| | 359| 2.19M|#define yyleng yyg->yyleng_r
------------------
2081| 2.19M|}
igraph_gml_yyget_text:
2088| 2.19M|{
2089| 2.19M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2090| 2.19M| return yytext;
------------------
| | 360| 2.19M|#define yytext yyg->yytext_r
------------------
2091| 2.19M|}
igraph_gml_yyset_extra:
2098| 7.15k|{
2099| 7.15k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2100| 7.15k| yyextra = user_defined ;
------------------
| | 358| 7.15k|#define yyextra yyg->yyextra_r
------------------
2101| 7.15k|}
igraph_gml_yyset_in:
2140| 3.57k|{
2141| 3.57k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2142| 3.57k| yyin = _in_str ;
------------------
| | 356| 3.57k|#define yyin yyg->yyin_r
------------------
2143| 3.57k|}
igraph_gml_yylex_init_extra:
2223| 3.57k|{
2224| 3.57k| struct yyguts_t dummy_yyguts;
2225| |
2226| 3.57k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.57k|#define yyset_extra igraph_gml_yyset_extra
------------------
2227| |
2228| 3.57k| if (ptr_yy_globals == NULL){
------------------
| Branch (2228:9): [True: 0, False: 3.57k]
------------------
2229| 0| errno = EINVAL;
2230| 0| return 1;
2231| 0| }
2232| |
2233| 3.57k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.57k|#define yyalloc igraph_gml_yyalloc
------------------
2234| |
2235| 3.57k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2235:9): [True: 0, False: 3.57k]
------------------
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.57k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2243| |
2244| 3.57k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.57k|#define yyset_extra igraph_gml_yyset_extra
------------------
2245| |
2246| 3.57k| return yy_init_globals ( *ptr_yy_globals );
2247| 3.57k|}
igraph_gml_yylex_destroy:
2284| 3.57k|{
2285| 3.57k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2286| |
2287| | /* Pop the buffer stack, destroying each element. */
2288| 7.15k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 7.15k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.57k, False: 3.57k]
| | | Branch (521:29): [True: 7.15k, False: 0]
| | ------------------
| | 522| 7.15k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 7.15k| : NULL)
------------------
2289| 3.57k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.57k|#define yy_delete_buffer igraph_gml_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.57k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.57k, False: 0]
| | ------------------
| | 522| 3.57k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.57k| : NULL)
------------------
2290| 3.57k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2291| 3.57k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.57k|#define yypop_buffer_state igraph_gml_yypop_buffer_state
------------------
2292| 3.57k| }
2293| |
2294| | /* Destroy the stack itself. */
2295| 3.57k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.57k|#define yyfree igraph_gml_yyfree
------------------
2296| 3.57k| yyg->yy_buffer_stack = NULL;
2297| |
2298| | /* Destroy the start condition stack. */
2299| 3.57k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.57k|#define yyfree igraph_gml_yyfree
------------------
2300| 3.57k| 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.57k| yy_init_globals( yyscanner);
2305| |
2306| | /* Destroy the main struct (reentrant only). */
2307| 3.57k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.57k|#define yyfree igraph_gml_yyfree
------------------
2308| | yyscanner = NULL;
2309| 3.57k| return 0;
2310| 3.57k|}
igraph_gml_yyalloc:
2340| 14.3k|{
2341| 14.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2342| 14.3k| (void)yyg;
2343| 14.3k| return malloc(size);
2344| 14.3k|}
igraph_gml_yyrealloc:
2347| 435|{
2348| 435| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2349| 435| (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| 435| return realloc(ptr, size);
2359| 435|}
igraph_gml_yyfree:
2362| 17.8k|{
2363| 17.8k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2364| 17.8k| (void)yyg;
2365| 17.8k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2366| 17.8k|}
gml-lexer.c:yy_get_next_buffer:
1348| 36.1k|{
1349| 36.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1350| 36.1k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1351| 36.1k| char *source = yyg->yytext_ptr;
------------------
| | 579| 36.1k|#define yytext_ptr yytext_r
------------------
1352| 36.1k| int number_to_move, i;
1353| 36.1k| int ret_val;
1354| |
1355| 36.1k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1355:7): [True: 0, False: 36.1k]
------------------
1356| 36.1k| 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| 36.1k| "fatal flex scanner internal error--end of buffer missed" );
1358| |
1359| 36.1k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1359:7): [True: 0, False: 36.1k]
------------------
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| 36.1k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 36.1k|#define yytext_ptr yytext_r
------------------
1382| |
1383| 1.53G| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1383:15): [True: 1.53G, False: 36.1k]
------------------
1384| 1.53G| *(dest++) = *(source++);
1385| |
1386| 36.1k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 510| 36.1k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1386:7): [True: 3.57k, False: 32.5k]
------------------
1387| | /* don't do the read, it's not guaranteed to return an EOF,
1388| | * just force an EOF
1389| | */
1390| 3.57k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 3.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1391| |
1392| 32.5k| else
1393| 32.5k| {
1394| 32.5k| int num_to_read =
1395| 32.5k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 32.5k|#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: 435, False: 32.5k]
------------------
1398| 435| { /* Not enough room in the buffer - grow it. */
1399| |
1400| | /* just a shorter name for the current buffer */
1401| 435| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 435|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1402| |
1403| 435| int yy_c_buf_p_offset =
1404| 435| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1405| |
1406| 435| if ( b->yy_is_our_buffer )
------------------
| Branch (1406:9): [True: 435, False: 0]
------------------
1407| 435| {
1408| 435| int new_size = b->yy_buf_size * 2;
1409| |
1410| 435| if ( new_size <= 0 )
------------------
| Branch (1410:10): [True: 0, False: 435]
------------------
1411| 0| b->yy_buf_size += b->yy_buf_size / 8;
1412| 435| else
1413| 435| b->yy_buf_size *= 2;
1414| |
1415| 435| b->yy_ch_buf = (char *)
1416| | /* Include room in for 2 EOB chars. */
1417| 435| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 435|#define yyrealloc igraph_gml_yyrealloc
------------------
1418| 435| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1419| 435| }
1420| 0| else
1421| | /* Can't grow it, we don't own it. */
1422| 0| b->yy_ch_buf = NULL;
1423| |
1424| 435| if ( ! b->yy_ch_buf )
------------------
| Branch (1424:9): [True: 0, False: 435]
------------------
1425| 435| 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| 435| "fatal error - scanner input buffer overflow" );
1427| |
1428| 435| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1429| |
1430| 435| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 435|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1431| 435| number_to_move - 1;
1432| |
1433| 435| }
1434| |
1435| 32.5k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 925| 32.5k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1435:8): [True: 30.1k, False: 2.41k]
------------------
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.5k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 942| 32.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 32.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (942:7): [True: 0, False: 32.5k]
| | ------------------
| | 943| 32.5k| { \
| | 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.5k| else \
| | 956| 32.5k| { \
| | 957| 32.5k| errno=0; \
| | 958| 32.5k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 32.5k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.57k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (958:11): [True: 3.57k, False: 28.9k]
| | | Branch (958:78): [True: 0, False: 3.57k]
| | ------------------
| | 959| 32.5k| { \
| | 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.5k| }\
------------------
1440| 32.5k| yyg->yy_n_chars, num_to_read );
1441| |
1442| 32.5k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 32.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1443| 32.5k| }
1444| |
1445| 36.1k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1445:7): [True: 7.15k, False: 28.9k]
------------------
1446| 7.15k| {
1447| 7.15k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 712| 7.15k|#define YY_MORE_ADJ 0
------------------
| Branch (1447:8): [True: 3.57k, False: 3.57k]
------------------
1448| 3.57k| {
1449| 3.57k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.57k|#define EOB_ACT_END_OF_FILE 1
------------------
1450| 3.57k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.57k|#define yyrestart igraph_gml_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.57k|#define yyin yyg->yyin_r
------------------
1451| 3.57k| }
1452| |
1453| 3.57k| else
1454| 3.57k| {
1455| 3.57k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 3.57k|#define EOB_ACT_LAST_MATCH 2
------------------
1456| 3.57k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 3.57k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1457| 3.57k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 3.57k|#define YY_BUFFER_EOF_PENDING 2
------------------
1458| 3.57k| }
1459| 7.15k| }
1460| |
1461| 28.9k| else
1462| 28.9k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 28.9k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1463| |
1464| 36.1k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1464:6): [True: 0, False: 36.1k]
------------------
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| 36.1k| yyg->yy_n_chars += number_to_move;
1476| 36.1k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 36.1k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1477| 36.1k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 36.1k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1478| |
1479| 36.1k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 36.1k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 36.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1480| |
1481| 36.1k| return ret_val;
1482| 36.1k|}
gml-lexer.c:yy_get_previous_state:
1487| 32.5k|{
1488| 32.5k| yy_state_type yy_current_state;
1489| 32.5k| char *yy_cp;
1490| 32.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1491| |
1492| 32.5k| yy_current_state = yyg->yy_start;
1493| 32.5k| yy_current_state += YY_AT_BOL();
------------------
| | 569| 32.5k|#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
| | ------------------
| | | | 527| 32.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1494| |
1495| 1.53G| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 579| 32.5k|#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.5k|#define YY_MORE_ADJ 0
------------------
| Branch (1495:47): [True: 1.53G, False: 32.5k]
------------------
1496| 1.53G| {
1497| 1.53G| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 23);
------------------
| | 346| 1.53G|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1497:19): [True: 1.53G, False: 0]
------------------
1498| 1.53G| if ( yy_accept[yy_current_state] )
------------------
| Branch (1498:8): [True: 82.3M, False: 1.45G]
------------------
1499| 82.3M| {
1500| 82.3M| yyg->yy_last_accepting_state = yy_current_state;
1501| 82.3M| yyg->yy_last_accepting_cpos = yy_cp;
1502| 82.3M| }
1503| 3.06G| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1503:11): [True: 1.53G, False: 1.53G]
------------------
1504| 1.53G| {
1505| 1.53G| yy_current_state = (int) yy_def[yy_current_state];
1506| 1.53G| if ( yy_current_state >= 43 )
------------------
| Branch (1506:9): [True: 1.53G, False: 22.1k]
------------------
1507| 1.53G| yy_c = yy_meta[yy_c];
1508| 1.53G| }
1509| 1.53G| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1510| 1.53G| }
1511| |
1512| 32.5k| return yy_current_state;
1513| 32.5k|}
gml-lexer.c:igraph_gml_yy_load_buffer_state:
1688| 10.7k|{
1689| 10.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1690| 10.7k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 10.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1691| 10.7k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 10.7k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 10.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1692| 10.7k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 10.7k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 10.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1693| 10.7k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1694| 10.7k|}
gml-lexer.c:igraph_gml_yy_init_buffer:
1752| 7.15k|{
1753| 7.15k| int oerrno = errno;
1754| 7.15k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1755| |
1756| 7.15k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 7.15k|#define yy_flush_buffer igraph_gml_yy_flush_buffer
------------------
1757| |
1758| 7.15k| b->yy_input_file = file;
1759| 7.15k| 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| 7.15k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 7.15k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 7.15k, False: 0]
| | ------------------
| | 522| 7.15k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 7.15k| : NULL)
------------------
| Branch (1765:9): [True: 3.57k, False: 3.57k]
------------------
1766| 3.57k| b->yy_bs_lineno = 1;
1767| 3.57k| b->yy_bs_column = 0;
1768| 3.57k| }
1769| |
1770| 7.15k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1770:32): [True: 7.15k, False: 0]
------------------
1771| |
1772| | errno = oerrno;
1773| 7.15k|}
gml-lexer.c:igraph_gml_yyensure_buffer_stack:
1861| 3.57k|{
1862| 3.57k| yy_size_t num_to_alloc;
1863| 3.57k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1864| |
1865| 3.57k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1865:6): [True: 3.57k, 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.57k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1872| 3.57k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.57k|#define yyalloc igraph_gml_yyalloc
------------------
1873| 3.57k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1874| 3.57k| , yyscanner);
1875| 3.57k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1875:8): [True: 0, False: 3.57k]
------------------
1876| 3.57k| 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.57k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1879| |
1880| 3.57k| yyg->yy_buffer_stack_max = num_to_alloc;
1881| 3.57k| yyg->yy_buffer_stack_top = 0;
1882| 3.57k| return;
1883| 3.57k| }
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| 7.15k|{
2251| 7.15k| 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| 7.15k| yyg->yy_buffer_stack = NULL;
2257| 7.15k| yyg->yy_buffer_stack_top = 0;
2258| 7.15k| yyg->yy_buffer_stack_max = 0;
2259| 7.15k| yyg->yy_c_buf_p = NULL;
2260| 7.15k| yyg->yy_init = 0;
2261| 7.15k| yyg->yy_start = 0;
2262| |
2263| 7.15k| yyg->yy_start_stack_ptr = 0;
2264| 7.15k| yyg->yy_start_stack_depth = 0;
2265| 7.15k| yyg->yy_start_stack = NULL;
2266| |
2267| |/* Defined in main.c */
2268| |#ifdef YY_STDINIT
2269| | yyin = stdin;
2270| | yyout = stdout;
2271| |#else
2272| 7.15k| yyin = NULL;
------------------
| | 356| 7.15k|#define yyin yyg->yyin_r
------------------
2273| 7.15k| yyout = NULL;
------------------
| | 357| 7.15k|#define yyout yyg->yyout_r
------------------
2274| 7.15k|#endif
2275| |
2276| | /* For future reference: Set errno on error, since we are called by
2277| | * yylex_init()
2278| | */
2279| 7.15k| return 0;
2280| 7.15k|}
igraph_gml_yyparse:
1239| 3.57k|{
1240| |/* The lookahead symbol. */
1241| 3.57k|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.57k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 380| 3.57k|# define YY_INITIAL_VALUE(Value) Value
------------------
1248| 3.57k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 380| 3.57k|# define YY_INITIAL_VALUE(Value) Value
------------------
1249| |
1250| |/* Location data for the lookahead symbol. */
1251| 3.57k|static YYLTYPE yyloc_default
1252| 3.57k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1253| 3.57k| = { 1, 1, 1, 1 }
1254| 3.57k|# endif
1255| 3.57k|;
1256| 3.57k|YYLTYPE yylloc = yyloc_default;
1257| |
1258| | /* Number of syntax errors so far. */
1259| 3.57k| int yynerrs;
1260| |
1261| 3.57k| yy_state_fast_t yystate;
1262| | /* Number of tokens to shift before error messages enabled. */
1263| 3.57k| 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.57k| yy_state_t yyssa[YYINITDEPTH];
1275| 3.57k| yy_state_t *yyss;
1276| 3.57k| yy_state_t *yyssp;
1277| |
1278| | /* The semantic value stack. */
1279| 3.57k| YYSTYPE yyvsa[YYINITDEPTH];
1280| 3.57k| YYSTYPE *yyvs;
1281| 3.57k| YYSTYPE *yyvsp;
1282| |
1283| | /* The location stack. */
1284| 3.57k| YYLTYPE yylsa[YYINITDEPTH];
1285| 3.57k| YYLTYPE *yyls;
1286| 3.57k| YYLTYPE *yylsp;
1287| |
1288| | /* The locations where the error started and ended. */
1289| 3.57k| YYLTYPE yyerror_range[3];
1290| |
1291| 3.57k| YYPTRDIFF_T yystacksize;
------------------
| | 295| 3.57k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1292| |
1293| 3.57k| int yyn;
1294| 3.57k| int yyresult;
1295| | /* Lookahead token as an internal (translated) token number. */
1296| 3.57k| int yytoken = 0;
1297| | /* The variables used to return semantic value and location from the
1298| | action routines. */
1299| 3.57k| YYSTYPE yyval;
1300| 3.57k| YYLTYPE yyloc;
1301| |
1302| 3.57k|#if YYERROR_VERBOSE
1303| | /* Buffer for error messages, and its allocated size. */
1304| 3.57k| char yymsgbuf[128];
1305| 3.57k| char *yymsg = yymsgbuf;
1306| 3.57k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 295| 3.57k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1307| 3.57k|#endif
1308| |
1309| 3.57k|#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.57k| int yylen = 0;
1314| |
1315| 3.57k| yyssp = yyss = yyssa;
1316| 3.57k| yyvsp = yyvs = yyvsa;
1317| 3.57k| yylsp = yyls = yylsa;
1318| 3.57k| yystacksize = YYINITDEPTH;
------------------
| | 936| 3.57k|# define YYINITDEPTH 200
------------------
1319| |
1320| 3.57k| YYDPRINTF ((stderr, "Starting parse\n"));
1321| |
1322| 3.57k| yystate = 0;
1323| 3.57k| yyerrstatus = 0;
1324| 3.57k| yynerrs = 0;
------------------
| | 71| 3.57k|#define yynerrs igraph_gml_yynerrs
------------------
1325| 3.57k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 700| 3.57k|#define YYEMPTY (-2)
------------------
1326| 3.57k| yylsp[0] = yylloc;
1327| 3.57k| goto yysetstate;
1328| |
1329| |
1330| |/*------------------------------------------------------------.
1331| || yynewstate -- push a new state, which is found in yystate. |
1332| |`------------------------------------------------------------*/
1333| 7.54M|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| 7.54M| yyssp++;
1337| |
1338| |
1339| |/*--------------------------------------------------------------------.
1340| || yysetstate -- set current state (the top of the stack) to yystate. |
1341| |`--------------------------------------------------------------------*/
1342| 7.54M|yysetstate:
1343| 7.54M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1344| 7.54M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 403| 7.54M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (403:31): [Folded, False: 7.54M]
| | | Branch (403:37): [True: 0, False: 0]
| | | Branch (403:37): [True: 0, False: 0]
| | ------------------
------------------
1345| 7.54M| YY_IGNORE_USELESS_CAST_BEGIN
1346| 7.54M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 143| 7.54M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1347| 7.54M| YY_IGNORE_USELESS_CAST_END
1348| |
1349| 7.54M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1349:7): [True: 0, False: 7.54M]
------------------
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| 7.54M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1416| |
1417| 7.54M| if (yystate == YYFINAL)
------------------
| | 537| 7.54M|#define YYFINAL 6
------------------
| Branch (1417:7): [True: 3.57k, False: 7.54M]
------------------
1418| 3.57k| YYACCEPT;
------------------
| | 703| 3.57k|#define YYACCEPT goto yyacceptlab
------------------
1419| |
1420| 7.54M| goto yybackup;
1421| |
1422| |
1423| |/*-----------.
1424| || yybackup. |
1425| |`-----------*/
1426| 7.54M|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| 7.54M| yyn = yypact[yystate];
1432| 7.54M| if (yypact_value_is_default (yyn))
------------------
| | 624| 7.54M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 621| 7.54M|#define YYPACT_NINF (-4)
| | ------------------
| | | Branch (624:3): [True: 4.70M, False: 2.83M]
| | ------------------
------------------
1433| 4.70M| 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| 2.83M| if (yychar == YYEMPTY)
------------------
| | 700| 2.83M|#define YYEMPTY (-2)
------------------
| Branch (1438:7): [True: 2.83M, False: 3.57k]
------------------
1439| 2.83M| {
1440| 2.83M| YYDPRINTF ((stderr, "Reading a token: "));
1441| 2.83M| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 2.83M|#define yylex igraph_gml_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 133| 2.83M|#define scanner context->scanner
------------------
1442| 2.83M| }
1443| |
1444| 2.83M| if (yychar <= YYEOF)
------------------
| | 701| 2.83M|#define YYEOF 0
------------------
| Branch (1444:7): [True: 7.15k, False: 2.83M]
------------------
1445| 7.15k| {
1446| 7.15k| yychar = yytoken = YYEOF;
------------------
| | 701| 7.15k|#define YYEOF 0
------------------
1447| 7.15k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1448| 7.15k| }
1449| 2.83M| else
1450| 2.83M| {
1451| 2.83M| yytoken = YYTRANSLATE (yychar);
------------------
| | 557| 2.83M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 551| 2.83M|#define YYMAXUTOK 263
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 550| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (557:4): [True: 2.83M, False: 0]
| | | Branch (557:18): [True: 2.83M, False: 0]
| | ------------------
------------------
1452| 2.83M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1453| 2.83M| }
1454| |
1455| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1456| | detect an error, take that action. */
1457| 2.83M| yyn += yytoken;
1458| 2.83M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 539| 2.83M|#define YYLAST 10
------------------
| Branch (1458:7): [True: 0, False: 2.83M]
| Branch (1458:18): [True: 0, False: 2.83M]
| Branch (1458:34): [True: 3.57k, False: 2.83M]
------------------
1459| 3.57k| goto yydefault;
1460| 2.83M| yyn = yytable[yyn];
1461| 2.83M| if (yyn <= 0)
------------------
| Branch (1461:7): [True: 0, False: 2.83M]
------------------
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| 2.83M| if (yyerrstatus)
------------------
| Branch (1471:7): [True: 0, False: 2.83M]
------------------
1472| 0| yyerrstatus--;
1473| |
1474| | /* Shift the lookahead token. */
1475| 2.83M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1476| 2.83M| yystate = yyn;
1477| 2.83M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1478| 2.83M| *++yyvsp = yylval;
1479| 2.83M| YY_IGNORE_MAYBE_UNINITIALIZED_END
1480| 2.83M| *++yylsp = yylloc;
1481| |
1482| | /* Discard the shifted token. */
1483| 2.83M| yychar = YYEMPTY;
------------------
| | 700| 2.83M|#define YYEMPTY (-2)
------------------
1484| 2.83M| goto yynewstate;
1485| |
1486| |
1487| |/*-----------------------------------------------------------.
1488| || yydefault -- do the default action for the current state. |
1489| |`-----------------------------------------------------------*/
1490| 4.71M|yydefault:
1491| 4.71M| yyn = yydefact[yystate];
1492| 4.71M| if (yyn == 0)
------------------
| Branch (1492:7): [True: 0, False: 4.71M]
------------------
1493| 0| goto yyerrlab;
1494| 4.71M| goto yyreduce;
1495| |
1496| |
1497| |/*-----------------------------.
1498| || yyreduce -- do a reduction. |
1499| |`-----------------------------*/
1500| 4.71M|yyreduce:
1501| | /* yyn is the number of a rule to reduce with. */
1502| 4.71M| 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| 4.71M| yyval = yyvsp[1-yylen];
1513| |
1514| | /* Default location. */
1515| 4.71M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 738| 4.71M| do \
| | 739| 4.71M| if (N) \
| | ------------------
| | | Branch (739:11): [True: 4.71M, False: 0]
| | ------------------
| | 740| 4.71M| { \
| | 741| 4.71M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 756| 4.71M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 742| 4.71M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 756| 4.71M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 743| 4.71M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 756| 4.71M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 744| 4.71M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 756| 4.71M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 745| 4.71M| } \
| | 746| 4.71M| else \
| | 747| 4.71M| { \
| | 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| 4.71M| while (0)
| | ------------------
| | | Branch (753:12): [Folded, False: 4.71M]
| | ------------------
------------------
1516| 4.71M| yyerror_range[1] = yyloc;
1517| 4.71M| YY_REDUCE_PRINT (yyn);
1518| 4.71M| switch (yyn)
1519| 4.71M| {
1520| 3.57k| case 2:
------------------
| Branch (1520:3): [True: 3.57k, False: 4.70M]
------------------
1521| 3.57k|#line 122 "/src/igraph/src/io/gml-parser.y"
1522| 3.57k| { context->tree=(yyvsp[0].tree); }
1523| 3.57k|#line 1524 "/src/igraph/build/src/io/parsers/gml-parser.c"
1524| 3.57k| break;
1525| |
1526| 0| case 3:
------------------
| Branch (1526:3): [True: 0, False: 4.71M]
------------------
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| 320k| case 4:
------------------
| Branch (1532:3): [True: 320k, False: 4.39M]
------------------
1533| 320k|#line 125 "/src/igraph/src/io/gml-parser.y"
1534| 320k| { (yyval.tree)=(yyvsp[0].tree); }
1535| 320k|#line 1536 "/src/igraph/build/src/io/parsers/gml-parser.c"
1536| 320k| break;
1537| |
1538| 935k| case 5:
------------------
| Branch (1538:3): [True: 935k, False: 3.77M]
------------------
1539| 935k|#line 126 "/src/igraph/src/io/gml-parser.y"
1540| 935k| { IGRAPH_YY_CHECK(igraph_i_gml_merge((yyvsp[-1].tree), (yyvsp[0].tree))); (yyval.tree) = (yyvsp[-1].tree); }
------------------
| | 10| 935k| do { \
| | 11| 935k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 935k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 935k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 935k]
| | | | ------------------
| | ------------------
| | 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| 935k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 935k]
| | ------------------
------------------
1541| 0|#line 1542 "/src/igraph/build/src/io/parsers/gml-parser.c"
1542| 0| break;
1543| |
1544| 615k| case 6:
------------------
| Branch (1544:3): [True: 615k, False: 4.09M]
------------------
1545| 615k|#line 129 "/src/igraph/src/io/gml-parser.y"
1546| 615k| { IGRAPH_YY_CHECK(igraph_i_gml_make_numeric((yyvsp[-1].str), (yylsp[-1]).first_line, (yyvsp[0].real), &(yyval.tree))); }
------------------
| | 10| 615k| do { \
| | 11| 615k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 615k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 615k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 615k]
| | | | ------------------
| | ------------------
| | 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| 615k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 615k]
| | ------------------
------------------
1547| 615k|#line 1548 "/src/igraph/build/src/io/parsers/gml-parser.c"
1548| 615k| break;
1549| |
1550| 615k| case 7:
------------------
| Branch (1550:3): [True: 323k, False: 4.38M]
------------------
1551| 323k|#line 131 "/src/igraph/src/io/gml-parser.y"
1552| 323k| { IGRAPH_YY_CHECK(igraph_i_gml_make_string((yyvsp[-1].str), (yylsp[-1]).first_line, (yyvsp[0].str), &(yyval.tree))); }
------------------
| | 10| 323k| do { \
| | 11| 323k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 323k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 323k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 323k]
| | | | ------------------
| | ------------------
| | 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| 323k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 323k]
| | ------------------
------------------
1553| 323k|#line 1554 "/src/igraph/build/src/io/parsers/gml-parser.c"
1554| 323k| break;
1555| |
1556| 323k| case 8:
------------------
| Branch (1556:3): [True: 317k, False: 4.39M]
------------------
1557| 317k|#line 133 "/src/igraph/src/io/gml-parser.y"
1558| 317k| { IGRAPH_YY_CHECK(igraph_i_gml_make_list((yyvsp[-3].str), (yylsp[-3]).first_line, (yyvsp[-1].tree), &(yyval.tree))); }
------------------
| | 10| 317k| do { \
| | 11| 317k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 317k]
| | | | ------------------
| | ------------------
| | 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| 317k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 317k]
| | ------------------
------------------
1559| 317k|#line 1560 "/src/igraph/build/src/io/parsers/gml-parser.c"
1560| 317k| break;
1561| |
1562| 1.25M| case 9:
------------------
| Branch (1562:3): [True: 1.25M, False: 3.45M]
------------------
1563| 1.25M|#line 136 "/src/igraph/src/io/gml-parser.y"
1564| 1.25M| { IGRAPH_YY_CHECK(igraph_i_gml_get_keyword(igraph_gml_yyget_text(scanner),
------------------
| | 10| 1.25M| do { \
| | 11| 1.25M| igraph_error_t igraph_i_ret = (expr); \
| | 12| 1.25M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 1.25M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.25M]
| | | | ------------------
| | ------------------
| | 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.25M| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 1.25M]
| | ------------------
------------------
1565| 1.25M| igraph_gml_yyget_leng(scanner),
1566| 1.25M| &(yyval.str))); }
1567| 1.25M|#line 1568 "/src/igraph/build/src/io/parsers/gml-parser.c"
1568| 1.25M| break;
1569| |
1570| 1.25M| case 10:
------------------
| Branch (1570:3): [True: 615k, False: 4.09M]
------------------
1571| 615k|#line 139 "/src/igraph/src/io/gml-parser.y"
1572| 615k| {
1573| 615k| igraph_real_t val;
1574| 615k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_gml_yyget_text(scanner),
------------------
| | 10| 615k| do { \
| | 11| 615k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 615k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 615k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 615k]
| | | | ------------------
| | ------------------
| | 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| 615k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 615k]
| | ------------------
------------------
1575| 615k| igraph_gml_yyget_leng(scanner),
1576| 615k| &val));
1577| 615k| (yyval.real)=val;
1578| 615k|}
1579| 0|#line 1580 "/src/igraph/build/src/io/parsers/gml-parser.c"
1580| 0| break;
1581| |
1582| 323k| case 11:
------------------
| Branch (1582:3): [True: 323k, False: 4.38M]
------------------
1583| 323k|#line 147 "/src/igraph/src/io/gml-parser.y"
1584| 323k| { IGRAPH_YY_CHECK(igraph_i_gml_get_string(igraph_gml_yyget_text(scanner),
------------------
| | 10| 323k| do { \
| | 11| 323k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 323k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 323k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 323k]
| | | | ------------------
| | ------------------
| | 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| 323k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 323k]
| | ------------------
------------------
1585| 323k| igraph_gml_yyget_leng(scanner),
1586| 323k| &(yyval.str))); }
1587| 323k|#line 1588 "/src/igraph/build/src/io/parsers/gml-parser.c"
1588| 323k| break;
1589| |
1590| |
1591| 323k|#line 1592 "/src/igraph/build/src/io/parsers/gml-parser.c"
1592| |
1593| 323k| default: break;
------------------
| Branch (1593:7): [True: 0, False: 4.71M]
------------------
1594| 4.71M| }
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| 4.71M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1607| |
1608| 4.71M| YYPOPSTACK (yylen);
------------------
| | 1309| 4.71M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1609| 4.71M| yylen = 0;
1610| 4.71M| YY_STACK_PRINT (yyss, yyssp);
1611| |
1612| 4.71M| *++yyvsp = yyval;
1613| 4.71M| *++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| 4.71M| {
1619| 4.71M| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 542| 4.71M|#define YYNTOKENS 9
------------------
1620| 4.71M| const int yyi = yypgoto[yylhs] + *yyssp;
1621| 4.71M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 539| 9.39M|#define YYLAST 10
------------------
| Branch (1621:16): [True: 4.68M, False: 28.6k]
| Branch (1621:28): [True: 4.68M, False: 0]
| Branch (1621:45): [True: 2.18M, False: 2.50M]
------------------
1622| 4.71M| ? yytable[yyi]
1623| 4.71M| : yydefgoto[yylhs]);
1624| 4.71M| }
1625| |
1626| 4.71M| 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.57k|yyacceptlab:
1774| 3.57k| yyresult = 0;
1775| 3.57k| 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.57k|yyreturn:
1801| 3.57k| if (yychar != YYEMPTY)
------------------
| | 700| 3.57k|#define YYEMPTY (-2)
------------------
| Branch (1801:7): [True: 0, False: 3.57k]
------------------
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.57k| YYPOPSTACK (yylen);
------------------
| | 1309| 3.57k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1812| 3.57k| YY_STACK_PRINT (yyss, yyssp);
1813| 10.7k| while (yyssp != yyss)
------------------
| Branch (1813:10): [True: 7.15k, False: 3.57k]
------------------
1814| 7.15k| {
1815| 7.15k| yydestruct ("Cleanup: popping",
1816| 7.15k| yystos[+*yyssp], yyvsp, yylsp, context);
1817| 7.15k| YYPOPSTACK (1);
------------------
| | 1309| 7.15k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1818| 7.15k| }
1819| 3.57k|#ifndef yyoverflow
1820| 3.57k| if (yyss != yyssa)
------------------
| Branch (1820:7): [True: 0, False: 3.57k]
------------------
1821| 0| YYSTACK_FREE (yyss);
------------------
| | 445| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 464| 0|# define YYFREE free
| | ------------------
------------------
1822| 3.57k|#endif
1823| 3.57k|#if YYERROR_VERBOSE
1824| 3.57k| if (yymsg != yymsgbuf)
------------------
| Branch (1824:7): [True: 0, False: 3.57k]
------------------
1825| 0| YYSTACK_FREE (yymsg);
------------------
| | 445| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 464| 0|# define YYFREE free
| | ------------------
------------------
1826| 3.57k|#endif
1827| 3.57k| return yyresult;
1828| 0|}
gml-parser.c:yydestruct:
1189| 7.15k|{
1190| 7.15k| YYUSE (yyvaluep);
------------------
| | 366| 7.15k|# define YYUSE(E) ((void) (E))
------------------
1191| 7.15k| YYUSE (yylocationp);
------------------
| | 366| 7.15k|# define YYUSE(E) ((void) (E))
------------------
1192| 7.15k| YYUSE (context);
------------------
| | 366| 7.15k|# define YYUSE(E) ((void) (E))
------------------
1193| 7.15k| if (!yymsg)
------------------
| Branch (1193:7): [True: 0, False: 7.15k]
------------------
1194| 0| yymsg = "Deleting";
1195| 7.15k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1196| |
1197| 7.15k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1198| 7.15k| switch (yytype)
1199| 7.15k| {
1200| 0| case 11: /* list */
------------------
| Branch (1200:5): [True: 0, False: 7.15k]
------------------
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: 7.15k]
------------------
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: 7.15k]
------------------
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: 7.15k]
------------------
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| 7.15k| default:
------------------
| Branch (1224:7): [True: 7.15k, False: 0]
------------------
1225| 7.15k| break;
1226| 7.15k| }
1227| 7.15k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1228| 7.15k|}
gml-parser.c:igraph_i_gml_get_keyword:
1840| 1.25M|static igraph_error_t igraph_i_gml_get_keyword(const char *s, size_t len, char **res) {
1841| 1.25M| *res = strndup(s, len);
1842| 1.25M| if (! *res) {
------------------
| Branch (1842:7): [True: 0, False: 1.25M]
------------------
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.25M| return IGRAPH_SUCCESS;
1846| 1.25M|}
gml-parser.c:igraph_i_gml_get_string:
1848| 323k|static igraph_error_t igraph_i_gml_get_string(const char *s, size_t len, char **res) {
1849| 323k| *res = strndup(s+1, len-2);
1850| 323k| if (! *res) {
------------------
| Branch (1850:7): [True: 0, False: 323k]
------------------
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| 323k| return IGRAPH_SUCCESS;
1854| 323k|}
gml-parser.c:igraph_i_gml_make_numeric:
1859| 615k| igraph_gml_tree_t **tree) {
1860| |
1861| 615k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 615k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.23M| (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: 615k, Folded]
| | | | ------------------
| | ------------------
------------------
1862| 615k| if (!t) {
------------------
| Branch (1862:7): [True: 0, False: 615k]
------------------
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| 615k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 615k| do { \
| | 604| 615k| /* the following branch makes the compiler check the compatibility of \
| | 605| 615k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 615k| * incorrect destructor function with the pointer */ \
| | 607| 615k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 615k]
| | ------------------
| | 608| 615k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 615k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 615k]
| | ------------------
------------------
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| 615k| igraph_real_t trunc_value = trunc(value);
1874| 615k| if (value == trunc_value && igraph_i_is_real_representable_as_integer(trunc_value)) {
------------------
| Branch (1874:7): [True: 614k, False: 701]
| Branch (1874:31): [True: 614k, False: 253]
------------------
1875| 614k| IGRAPH_CHECK(igraph_gml_tree_init_integer(t, name, line, value));
------------------
| | 656| 614k| do { \
| | 657| 614k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 614k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 614k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 614k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 614k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 614k]
| | ------------------
------------------
1876| 614k| } else {
1877| 954| IGRAPH_CHECK(igraph_gml_tree_init_real(t, name, line, value));
------------------
| | 656| 954| do { \
| | 657| 954| igraph_error_t igraph_i_ret = (expr); \
| | 658| 954| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 954| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 954]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 954| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 954]
| | ------------------
------------------
1878| 954| }
1879| |
1880| 615k| *tree = t;
1881| 615k| IGRAPH_FINALLY_CLEAN(1); /* t */
1882| |
1883| 615k| return IGRAPH_SUCCESS;
1884| 615k|}
gml-parser.c:igraph_i_gml_make_string:
1889| 323k| igraph_gml_tree_t **tree) {
1890| |
1891| 323k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 323k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 647k| (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: 323k, Folded]
| | | | ------------------
| | ------------------
------------------
1892| 323k| if (!t) {
------------------
| Branch (1892:7): [True: 0, False: 323k]
------------------
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| 323k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 323k| do { \
| | 604| 323k| /* the following branch makes the compiler check the compatibility of \
| | 605| 323k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 323k| * incorrect destructor function with the pointer */ \
| | 607| 323k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 323k]
| | ------------------
| | 608| 323k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 323k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 323k]
| | ------------------
------------------
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| 323k| IGRAPH_FINALLY(igraph_free, value);
------------------
| | 603| 323k| do { \
| | 604| 323k| /* the following branch makes the compiler check the compatibility of \
| | 605| 323k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 323k| * incorrect destructor function with the pointer */ \
| | 607| 323k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 323k]
| | ------------------
| | 608| 323k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 323k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 323k]
| | ------------------
------------------
1901| 323k| IGRAPH_CHECK(igraph_gml_tree_init_string(t, name, line, value));
------------------
| | 656| 323k| do { \
| | 657| 323k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 323k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 323k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 323k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 323k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 323k]
| | ------------------
------------------
1902| |
1903| 323k| IGRAPH_FINALLY_CLEAN(1); /* value */
1904| |
1905| 323k| *tree = t;
1906| 323k| IGRAPH_FINALLY_CLEAN(1); /* t */
1907| |
1908| 323k| return IGRAPH_SUCCESS;
1909| 323k|}
gml-parser.c:igraph_i_gml_make_list:
1914| 317k| igraph_gml_tree_t **tree) {
1915| |
1916| 317k| igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
------------------
| | 33| 317k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 634k| (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: 317k, Folded]
| | | | ------------------
| | ------------------
------------------
1917| 317k| if (!t) {
------------------
| Branch (1917:7): [True: 0, False: 317k]
------------------
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| 317k| IGRAPH_FINALLY(igraph_free, t);
------------------
| | 603| 317k| do { \
| | 604| 317k| /* the following branch makes the compiler check the compatibility of \
| | 605| 317k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 317k| * incorrect destructor function with the pointer */ \
| | 607| 317k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 317k]
| | ------------------
| | 608| 317k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 317k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 317k]
| | ------------------
------------------
1921| |
1922| 317k| IGRAPH_CHECK(igraph_gml_tree_init_tree(t, name, line, list));
------------------
| | 656| 317k| do { \
| | 657| 317k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 317k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 317k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 317k]
| | ------------------
------------------
1923| |
1924| 317k| *tree = t;
1925| 317k| IGRAPH_FINALLY_CLEAN(1); /* t */
1926| |
1927| 317k| return IGRAPH_SUCCESS;
1928| 317k|}
gml-parser.c:igraph_i_gml_merge:
1945| 935k|static igraph_error_t igraph_i_gml_merge(igraph_gml_tree_t *t1, igraph_gml_tree_t* t2) {
1946| |
1947| 935k| IGRAPH_CHECK(igraph_gml_tree_mergedest(t1, t2));
------------------
| | 656| 935k| do { \
| | 657| 935k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 935k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 935k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 935k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 935k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 935k]
| | ------------------
------------------
1948| 935k| IGRAPH_FREE(t2);
------------------
| | 36| 935k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1949| |
1950| 935k| return IGRAPH_SUCCESS;
1951| 935k|}
igraph_lgl_yylex:
994| 680k|{
995| 680k| yy_state_type yy_current_state;
996| 680k| char *yy_cp, *yy_bp;
997| 680k| int yy_act;
998| 680k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
999| |
1000| 680k| yylval = yylval_param;
------------------
| | 807| 680k| # define yylval yyg->yylval_r
------------------
1001| |
1002| 680k| yylloc = yylloc_param;
------------------
| | 809| 680k| # define yylloc yyg->yylloc_r
------------------
1003| |
1004| 680k| if ( !yyg->yy_init )
------------------
| Branch (1004:7): [True: 3.42k, False: 677k]
------------------
1005| 3.42k| {
1006| 3.42k| yyg->yy_init = 1;
1007| |
1008| |#ifdef YY_USER_INIT
1009| | YY_USER_INIT;
1010| |#endif
1011| |
1012| 3.42k| if ( ! yyg->yy_start )
------------------
| Branch (1012:8): [True: 3.42k, False: 0]
------------------
1013| 3.42k| yyg->yy_start = 1; /* first start state */
1014| |
1015| 3.42k| if ( ! yyin )
------------------
| | 356| 3.42k|#define yyin yyg->yyin_r
------------------
| Branch (1015:8): [True: 0, False: 3.42k]
------------------
1016| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1017| |
1018| 3.42k| if ( ! yyout )
------------------
| | 357| 3.42k|#define yyout yyg->yyout_r
------------------
| Branch (1018:8): [True: 3.42k, False: 0]
------------------
1019| 3.42k| yyout = stdout;
------------------
| | 357| 3.42k|#define yyout yyg->yyout_r
------------------
1020| |
1021| 3.42k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.42k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.42k]
| | ------------------
| | 522| 3.42k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.42k| : NULL)
------------------
| Branch (1021:8): [True: 3.42k, False: 0]
------------------
1022| 3.42k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.42k|#define yyensure_buffer_stack igraph_lgl_yyensure_buffer_stack
------------------
1023| 3.42k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.42k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1024| 3.42k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.42k|#define yy_create_buffer igraph_lgl_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.42k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.42k|#define YY_BUF_SIZE 16384
------------------
1025| 3.42k| }
1026| |
1027| 3.42k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.42k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1028| 3.42k| }
1029| |
1030| 680k| {
1031| 680k|#line 79 "/src/igraph/src/io/lgl-lexer.l"
1032| |
1033| |
1034| 680k|#line 82 "/src/igraph/src/io/lgl-lexer.l"
1035| | /* ------------------------------------------------whitespace------*/
1036| 680k|#line 1037 "/src/igraph/build/src/io/parsers/lgl-lexer.c"
1037| |
1038| 775k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1038:23): [True: 775k, Folded]
------------------
1039| 775k| {
1040| 775k| yy_cp = yyg->yy_c_buf_p;
1041| |
1042| | /* Support of yytext. */
1043| 775k| *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| 775k| yy_bp = yy_cp;
1049| |
1050| 775k| yy_current_state = yyg->yy_start;
1051| 783k|yy_match:
1052| 783k| do
1053| 41.1M| {
1054| 41.1M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 41.1M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1055| 41.1M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1055:9): [True: 40.4M, False: 778k]
------------------
1056| 40.4M| {
1057| 40.4M| yyg->yy_last_accepting_state = yy_current_state;
1058| 40.4M| yyg->yy_last_accepting_cpos = yy_cp;
1059| 40.4M| }
1060| 82.8M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1060:12): [True: 41.6M, False: 41.1M]
------------------
1061| 41.6M| {
1062| 41.6M| yy_current_state = (int) yy_def[yy_current_state];
1063| 41.6M| if ( yy_current_state >= 16 )
------------------
| Branch (1063:10): [True: 40.3M, False: 1.25M]
------------------
1064| 40.3M| yy_c = yy_meta[yy_c];
1065| 41.6M| }
1066| 41.1M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1067| 41.1M| ++yy_cp;
1068| 41.1M| }
1069| 41.1M| while ( yy_base[yy_current_state] != 12 );
------------------
| Branch (1069:11): [True: 40.4M, False: 783k]
------------------
1070| |
1071| 785k|yy_find_action:
1072| 785k| yy_act = yy_accept[yy_current_state];
1073| 785k| if ( yy_act == 0 )
------------------
| Branch (1073:8): [True: 770k, False: 15.4k]
------------------
1074| 770k| { /* have to back up */
1075| 770k| yy_cp = yyg->yy_last_accepting_cpos;
1076| 770k| yy_current_state = yyg->yy_last_accepting_state;
1077| 770k| yy_act = yy_accept[yy_current_state];
1078| 770k| }
1079| |
1080| 785k| YY_DO_BEFORE_ACTION;
------------------
| | 590| 785k| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 785k|#define yytext_ptr yytext_r
| | ------------------
| | 591| 785k| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 785k|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 785k| yyg->yy_hold_char = *yy_cp; \
| | 593| 785k| *yy_cp = '\0'; \
| | 594| 785k| yyg->yy_c_buf_p = yy_cp;
------------------
1081| |
1082| 785k| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 1.57M|#define YY_END_OF_BUFFER 7
------------------
| Branch (1082:8): [True: 772k, False: 13.4k]
| Branch (1082:38): [True: 291k, False: 481k]
------------------
1083| 291k| {
1084| 291k| int yyl;
1085| 582k| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 582k|#define yyleng yyg->yyleng_r
------------------
| Branch (1085:19): [True: 291k, False: 291k]
------------------
1086| 291k| if ( yytext[yyl] == '\n' )
------------------
| | 360| 291k|#define yytext yyg->yytext_r
------------------
| Branch (1086:10): [True: 291k, False: 0]
------------------
1087| |
1088| 291k| do{ yylineno++;
------------------
| | 361| 291k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 291k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1089| 291k| yycolumn=0;
------------------
| | 362| 291k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 291k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1090| 291k| }while(0)
------------------
| Branch (1090:12): [Folded, False: 291k]
------------------
1091| 291k|;
1092| 291k| }
1093| |
1094| 789k|do_action: /* This label is used only to access EOF actions. */
1095| |
1096| 789k| switch ( yy_act )
1097| 789k| { /* beginning of action switch */
1098| 0| case 0: /* must back up */
------------------
| Branch (1098:4): [True: 0, False: 789k]
------------------
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| 95.2k|case 1:
------------------
| Branch (1105:1): [True: 95.2k, False: 694k]
------------------
1106| 95.2k|YY_RULE_SETUP
------------------
| | 989| 95.2k| YY_USER_ACTION
| | ------------------
| | | | 735| 95.2k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 95.2k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 95.2k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 95.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1107| 95.2k|#line 83 "/src/igraph/src/io/lgl-lexer.l"
1108| 95.2k|{ /* skip space */ }
1109| 95.2k| YY_BREAK
------------------
| | 985| 95.2k|#define YY_BREAK /*LINTED*/break;
------------------
1110| |/* --------------------------------------------------hashmark------*/
1111| 12.9k|case 2:
------------------
| Branch (1111:1): [True: 12.9k, False: 776k]
------------------
1112| 12.9k|YY_RULE_SETUP
------------------
| | 989| 12.9k| YY_USER_ACTION
| | ------------------
| | | | 735| 12.9k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 12.9k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 12.9k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 12.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1113| 12.9k|#line 86 "/src/igraph/src/io/lgl-lexer.l"
1114| 12.9k|{ BEGIN(LINE); return HASH; }
------------------
| | 369| 12.9k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return HASH; }
------------------
| | 751| 12.9k|#define LINE 1
------------------
1115| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1116| |/* ----------------------------------------------alphanumeric------*/
1117| 373k|case 3:
------------------
| Branch (1117:1): [True: 373k, False: 416k]
------------------
1118| 373k|YY_RULE_SETUP
------------------
| | 989| 373k| YY_USER_ACTION
| | ------------------
| | | | 735| 373k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 373k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 373k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 373k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1119| 373k|#line 89 "/src/igraph/src/io/lgl-lexer.l"
1120| 373k|{ BEGIN(LINE); return ALNUM; }
------------------
| | 369| 373k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return ALNUM; }
------------------
| | 751| 373k|#define LINE 1
------------------
1121| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1122| |/* ---------------------------------------------------newline------*/
1123| 291k|case 4:
------------------
| Branch (1123:1): [True: 291k, False: 498k]
------------------
1124| |/* rule 4 can match eol */
1125| 291k|#line 93 "/src/igraph/src/io/lgl-lexer.l"
1126| 291k|YY_RULE_SETUP
------------------
| | 989| 291k| YY_USER_ACTION
| | ------------------
| | | | 735| 291k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 291k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 291k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 291k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1127| 291k|case YY_STATE_EOF(LINE):
------------------
| | 377| 291k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 291k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
| Branch (1127:1): [True: 0, False: 789k]
------------------
1128| 291k|#line 93 "/src/igraph/src/io/lgl-lexer.l"
1129| 291k|{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 369| 291k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 750| 291k|#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: 789k]
------------------
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: 789k]
------------------
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.42k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.42k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.42k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
| Branch (1143:1): [True: 3.42k, False: 785k]
------------------
1144| 3.42k| yyterminate();
------------------
| | 948| 3.42k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.42k|#define YY_NULL 0
| | ------------------
------------------
1145| |
1146| 13.4k| case YY_END_OF_BUFFER:
------------------
| | 596| 13.4k|#define YY_END_OF_BUFFER 7
------------------
| Branch (1146:2): [True: 13.4k, False: 775k]
------------------
1147| 13.4k| {
1148| | /* Amount of text matched not including the EOB char. */
1149| 13.4k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 13.4k|#define yytext_ptr yytext_r
------------------
1150| |
1151| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1152| 13.4k| *yy_cp = yyg->yy_hold_char;
1153| 13.4k| YY_RESTORE_YY_MORE_OFFSET
1154| |
1155| 13.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 498| 13.4k|#define YY_BUFFER_NEW 0
------------------
| Branch (1155:8): [True: 3.42k, False: 9.98k]
------------------
1156| 3.42k| {
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.42k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.42k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1167| 3.42k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.42k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.42k|#define yyin yyg->yyin_r
------------------
1168| 3.42k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.42k|#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.42k|#define YY_BUFFER_NORMAL 1
------------------
1169| 3.42k| }
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.4k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1178:8): [True: 0, False: 13.4k]
------------------
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.4k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1214:17): [True: 13.4k, False: 0]
------------------
1215| 13.4k| {
1216| 3.42k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.42k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1216:4): [True: 3.42k, False: 9.98k]
------------------
1217| 3.42k| {
1218| 3.42k| yyg->yy_did_buffer_switch_on_eof = 0;
1219| |
1220| 3.42k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.42k|#define yywrap igraph_lgl_yywrap
| | ------------------
| | | | 573| 3.42k|#define igraph_lgl_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:38): [True: 3.42k, Folded]
| | | | ------------------
| | ------------------
------------------
1221| 3.42k| {
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.42k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.42k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 3.42k|#define YY_MORE_ADJ 0
------------------
1232| |
1233| 3.42k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.42k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.42k|#define YY_END_OF_BUFFER 7
| | ------------------
------------------
1234| 3.42k| goto do_action;
1235| 3.42k| }
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.42k| }
1244| |
1245| 7.52k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 7.52k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1245:4): [True: 7.52k, False: 5.88k]
------------------
1246| 7.52k| yyg->yy_c_buf_p =
1247| 7.52k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 7.52k|#define yytext_ptr yytext_r
------------------
1248| |
1249| 7.52k| yy_current_state = yy_get_previous_state( yyscanner );
1250| |
1251| 7.52k| yy_cp = yyg->yy_c_buf_p;
1252| 7.52k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 7.52k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 7.52k|#define YY_MORE_ADJ 0
------------------
1253| 7.52k| goto yy_match;
1254| |
1255| 2.45k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 2.45k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1255:4): [True: 2.45k, False: 10.9k]
------------------
1256| 2.45k| yyg->yy_c_buf_p =
1257| 2.45k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 2.45k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1258| |
1259| 2.45k| yy_current_state = yy_get_previous_state( yyscanner );
1260| |
1261| 2.45k| yy_cp = yyg->yy_c_buf_p;
1262| 2.45k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 2.45k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 2.45k|#define YY_MORE_ADJ 0
------------------
1263| 2.45k| goto yy_find_action;
1264| 13.4k| }
1265| 0| break;
1266| 13.4k| }
1267| |
1268| 0| default:
------------------
| Branch (1268:2): [True: 0, False: 789k]
------------------
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| 789k| "fatal flex scanner internal error--no action found" );
1271| 789k| } /* end of action switch */
1272| 789k| } /* end of scanning one token */
1273| 680k| } /* end of user's declarations */
1274| 680k|} /* end of yylex */
igraph_lgl_yyrestart:
1572| 3.42k|{
1573| 3.42k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1574| |
1575| 3.42k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.42k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.42k, False: 0]
| | ------------------
| | 522| 3.42k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.42k| : NULL)
------------------
| Branch (1575:7): [True: 0, False: 3.42k]
------------------
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.42k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.42k|#define yy_init_buffer igraph_lgl_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.42k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.42k, False: 0]
| | ------------------
| | 522| 3.42k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.42k| : NULL)
------------------
1582| 3.42k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.42k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1583| 3.42k|}
igraph_lgl_yy_create_buffer:
1637| 3.42k|{
1638| 3.42k| YY_BUFFER_STATE b;
1639| |
1640| 3.42k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.42k|#define yyalloc igraph_lgl_yyalloc
------------------
1641| 3.42k| if ( ! b )
------------------
| Branch (1641:7): [True: 0, False: 3.42k]
------------------
1642| 3.42k| 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.42k| 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.42k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.42k|#define yyalloc igraph_lgl_yyalloc
------------------
1650| 3.42k| if ( ! b->yy_ch_buf )
------------------
| Branch (1650:7): [True: 0, False: 3.42k]
------------------
1651| 3.42k| 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.42k| b->yy_is_our_buffer = 1;
1654| |
1655| 3.42k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.42k|#define yy_init_buffer igraph_lgl_yy_init_buffer
------------------
1656| |
1657| 3.42k| return b;
1658| 3.42k|}
igraph_lgl_yy_delete_buffer:
1665| 3.42k|{
1666| 3.42k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1667| |
1668| 3.42k| if ( ! b )
------------------
| Branch (1668:7): [True: 0, False: 3.42k]
------------------
1669| 0| return;
1670| |
1671| 3.42k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.42k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.42k, False: 0]
| | ------------------
| | 522| 3.42k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.42k| : NULL)
------------------
| Branch (1671:7): [True: 3.42k, False: 0]
------------------
1672| 3.42k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.42k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1673| |
1674| 3.42k| if ( b->yy_is_our_buffer )
------------------
| Branch (1674:7): [True: 3.42k, False: 0]
------------------
1675| 3.42k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.42k|#define yyfree igraph_lgl_yyfree
------------------
1676| |
1677| 3.42k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.42k|#define yyfree igraph_lgl_yyfree
------------------
1678| 3.42k|}
igraph_lgl_yy_flush_buffer:
1714| 6.85k|{
1715| 6.85k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1716| 6.85k| if ( ! b )
------------------
| Branch (1716:7): [True: 0, False: 6.85k]
------------------
1717| 0| return;
1718| |
1719| 6.85k| 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.85k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.85k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1726| 6.85k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.85k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1727| |
1728| 6.85k| b->yy_buf_pos = &b->yy_ch_buf[0];
1729| |
1730| 6.85k| b->yy_at_bol = 1;
1731| 6.85k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 6.85k|#define YY_BUFFER_NEW 0
------------------
1732| |
1733| 6.85k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 6.85k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.85k, False: 0]
| | ------------------
| | 522| 6.85k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.85k| : NULL)
------------------
| Branch (1733:7): [True: 3.42k, False: 3.42k]
------------------
1734| 3.42k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.42k|#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
------------------
1735| 6.85k|}
igraph_lgl_yypop_buffer_state:
1775| 3.42k|{
1776| 3.42k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1777| 3.42k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.42k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.42k, False: 0]
| | ------------------
| | 522| 3.42k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.42k| : NULL)
------------------
| Branch (1777:6): [True: 3.42k, False: 0]
------------------
1778| 3.42k| 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| 373k|{
2013| 373k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2014| 373k| return yyleng;
------------------
| | 359| 373k|#define yyleng yyg->yyleng_r
------------------
2015| 373k|}
igraph_lgl_yyget_text:
2022| 373k|{
2023| 373k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2024| 373k| return yytext;
------------------
| | 360| 373k|#define yytext yyg->yytext_r
------------------
2025| 373k|}
igraph_lgl_yyset_extra:
2032| 6.85k|{
2033| 6.85k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2034| 6.85k| yyextra = user_defined ;
------------------
| | 358| 6.85k|#define yyextra yyg->yyextra_r
------------------
2035| 6.85k|}
igraph_lgl_yyset_in:
2074| 3.42k|{
2075| 3.42k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2076| 3.42k| yyin = _in_str ;
------------------
| | 356| 3.42k|#define yyin yyg->yyin_r
------------------
2077| 3.42k|}
igraph_lgl_yylex_init_extra:
2157| 3.42k|{
2158| 3.42k| struct yyguts_t dummy_yyguts;
2159| |
2160| 3.42k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.42k|#define yyset_extra igraph_lgl_yyset_extra
------------------
2161| |
2162| 3.42k| if (ptr_yy_globals == NULL){
------------------
| Branch (2162:9): [True: 0, False: 3.42k]
------------------
2163| 0| errno = EINVAL;
2164| 0| return 1;
2165| 0| }
2166| |
2167| 3.42k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.42k|#define yyalloc igraph_lgl_yyalloc
------------------
2168| |
2169| 3.42k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2169:9): [True: 0, False: 3.42k]
------------------
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.42k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2177| |
2178| 3.42k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.42k|#define yyset_extra igraph_lgl_yyset_extra
------------------
2179| |
2180| 3.42k| return yy_init_globals ( *ptr_yy_globals );
2181| 3.42k|}
igraph_lgl_yylex_destroy:
2218| 3.42k|{
2219| 3.42k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2220| |
2221| | /* Pop the buffer stack, destroying each element. */
2222| 6.85k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 6.85k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.42k, False: 3.42k]
| | | Branch (521:29): [True: 6.85k, False: 0]
| | ------------------
| | 522| 6.85k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.85k| : NULL)
------------------
2223| 3.42k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.42k|#define yy_delete_buffer igraph_lgl_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.42k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.42k, False: 0]
| | ------------------
| | 522| 3.42k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.42k| : NULL)
------------------
2224| 3.42k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.42k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2225| 3.42k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.42k|#define yypop_buffer_state igraph_lgl_yypop_buffer_state
------------------
2226| 3.42k| }
2227| |
2228| | /* Destroy the stack itself. */
2229| 3.42k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.42k|#define yyfree igraph_lgl_yyfree
------------------
2230| 3.42k| yyg->yy_buffer_stack = NULL;
2231| |
2232| | /* Destroy the start condition stack. */
2233| 3.42k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.42k|#define yyfree igraph_lgl_yyfree
------------------
2234| 3.42k| 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.42k| yy_init_globals( yyscanner);
2239| |
2240| | /* Destroy the main struct (reentrant only). */
2241| 3.42k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.42k|#define yyfree igraph_lgl_yyfree
------------------
2242| | yyscanner = NULL;
2243| 3.42k| return 0;
2244| 3.42k|}
igraph_lgl_yyalloc:
2274| 13.7k|{
2275| 13.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2276| 13.7k| (void)yyg;
2277| 13.7k| return malloc(size);
2278| 13.7k|}
igraph_lgl_yyrealloc:
2281| 77|{
2282| 77| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2283| 77| (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| 77| return realloc(ptr, size);
2293| 77|}
igraph_lgl_yyfree:
2296| 17.1k|{
2297| 17.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2298| 17.1k| (void)yyg;
2299| 17.1k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2300| 17.1k|}
lgl-lexer.c:yy_get_next_buffer:
1284| 13.4k|{
1285| 13.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1286| 13.4k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1287| 13.4k| char *source = yyg->yytext_ptr;
------------------
| | 579| 13.4k|#define yytext_ptr yytext_r
------------------
1288| 13.4k| int number_to_move, i;
1289| 13.4k| int ret_val;
1290| |
1291| 13.4k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1291:7): [True: 0, False: 13.4k]
------------------
1292| 13.4k| 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.4k| "fatal flex scanner internal error--end of buffer missed" );
1294| |
1295| 13.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1295:7): [True: 0, False: 13.4k]
------------------
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.4k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 13.4k|#define yytext_ptr yytext_r
------------------
1318| |
1319| 233M| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1319:15): [True: 233M, False: 13.4k]
------------------
1320| 233M| *(dest++) = *(source++);
1321| |
1322| 13.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 510| 13.4k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1322:7): [True: 2.45k, False: 10.9k]
------------------
1323| | /* don't do the read, it's not guaranteed to return an EOF,
1324| | * just force an EOF
1325| | */
1326| 2.45k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 2.45k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1327| |
1328| 10.9k| else
1329| 10.9k| {
1330| 10.9k| int num_to_read =
1331| 10.9k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 10.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1332| |
1333| 11.0k| while ( num_to_read <= 0 )
------------------
| Branch (1333:11): [True: 77, False: 10.9k]
------------------
1334| 77| { /* Not enough room in the buffer - grow it. */
1335| |
1336| | /* just a shorter name for the current buffer */
1337| 77| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 77|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1338| |
1339| 77| int yy_c_buf_p_offset =
1340| 77| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1341| |
1342| 77| if ( b->yy_is_our_buffer )
------------------
| Branch (1342:9): [True: 77, False: 0]
------------------
1343| 77| {
1344| 77| int new_size = b->yy_buf_size * 2;
1345| |
1346| 77| if ( new_size <= 0 )
------------------
| Branch (1346:10): [True: 0, False: 77]
------------------
1347| 0| b->yy_buf_size += b->yy_buf_size / 8;
1348| 77| else
1349| 77| b->yy_buf_size *= 2;
1350| |
1351| 77| b->yy_ch_buf = (char *)
1352| | /* Include room in for 2 EOB chars. */
1353| 77| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 77|#define yyrealloc igraph_lgl_yyrealloc
------------------
1354| 77| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1355| 77| }
1356| 0| else
1357| | /* Can't grow it, we don't own it. */
1358| 0| b->yy_ch_buf = NULL;
1359| |
1360| 77| if ( ! b->yy_ch_buf )
------------------
| Branch (1360:9): [True: 0, False: 77]
------------------
1361| 77| 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| 77| "fatal error - scanner input buffer overflow" );
1363| |
1364| 77| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1365| |
1366| 77| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 77|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1367| 77| number_to_move - 1;
1368| |
1369| 77| }
1370| |
1371| 10.9k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 895| 10.9k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1371:8): [True: 10.2k, False: 701]
------------------
1372| 10.2k| num_to_read = YY_READ_BUF_SIZE;
------------------
| | 895| 10.2k|#define YY_READ_BUF_SIZE 8192
------------------
1373| |
1374| | /* Read in more data. */
1375| 10.9k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 912| 10.9k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 10.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (912:7): [True: 0, False: 10.9k]
| | ------------------
| | 913| 10.9k| { \
| | 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| 10.9k| else \
| | 926| 10.9k| { \
| | 927| 10.9k| errno=0; \
| | 928| 10.9k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 10.9k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.42k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (928:11): [True: 3.42k, False: 7.52k]
| | | Branch (928:78): [True: 0, False: 3.42k]
| | ------------------
| | 929| 10.9k| { \
| | 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| 10.9k| }\
------------------
1376| 10.9k| yyg->yy_n_chars, num_to_read );
1377| |
1378| 10.9k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 10.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1379| 10.9k| }
1380| |
1381| 13.4k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1381:7): [True: 5.88k, False: 7.52k]
------------------
1382| 5.88k| {
1383| 5.88k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 681| 5.88k|#define YY_MORE_ADJ 0
------------------
| Branch (1383:8): [True: 3.42k, False: 2.45k]
------------------
1384| 3.42k| {
1385| 3.42k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.42k|#define EOB_ACT_END_OF_FILE 1
------------------
1386| 3.42k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.42k|#define yyrestart igraph_lgl_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.42k|#define yyin yyg->yyin_r
------------------
1387| 3.42k| }
1388| |
1389| 2.45k| else
1390| 2.45k| {
1391| 2.45k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 2.45k|#define EOB_ACT_LAST_MATCH 2
------------------
1392| 2.45k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 2.45k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1393| 2.45k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 2.45k|#define YY_BUFFER_EOF_PENDING 2
------------------
1394| 2.45k| }
1395| 5.88k| }
1396| |
1397| 7.52k| else
1398| 7.52k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 7.52k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1399| |
1400| 13.4k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1400:6): [True: 0, False: 13.4k]
------------------
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.4k| yyg->yy_n_chars += number_to_move;
1412| 13.4k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 13.4k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1413| 13.4k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 13.4k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1414| |
1415| 13.4k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 13.4k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 13.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1416| |
1417| 13.4k| return ret_val;
1418| 13.4k|}
lgl-lexer.c:yy_get_previous_state:
1423| 9.98k|{
1424| 9.98k| yy_state_type yy_current_state;
1425| 9.98k| char *yy_cp;
1426| 9.98k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1427| |
1428| 9.98k| yy_current_state = yyg->yy_start;
1429| |
1430| 233M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 579| 9.98k|#define yytext_ptr yytext_r
------------------
for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 681| 9.98k|#define YY_MORE_ADJ 0
------------------
| Branch (1430:47): [True: 233M, False: 9.98k]
------------------
1431| 233M| {
1432| 233M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
------------------
| | 346| 233M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1432:19): [True: 233M, False: 0]
------------------
1433| 233M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1433:8): [True: 233M, False: 7.48k]
------------------
1434| 233M| {
1435| 233M| yyg->yy_last_accepting_state = yy_current_state;
1436| 233M| yyg->yy_last_accepting_cpos = yy_cp;
1437| 233M| }
1438| 467M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1438:11): [True: 233M, False: 233M]
------------------
1439| 233M| {
1440| 233M| yy_current_state = (int) yy_def[yy_current_state];
1441| 233M| if ( yy_current_state >= 16 )
------------------
| Branch (1441:9): [True: 233M, False: 3.91k]
------------------
1442| 233M| yy_c = yy_meta[yy_c];
1443| 233M| }
1444| 233M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1445| 233M| }
1446| |
1447| 9.98k| return yy_current_state;
1448| 9.98k|}
lgl-lexer.c:igraph_lgl_yy_load_buffer_state:
1622| 10.2k|{
1623| 10.2k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1624| 10.2k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 10.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1625| 10.2k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 10.2k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 10.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1626| 10.2k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 10.2k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 10.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1627| 10.2k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1628| 10.2k|}
lgl-lexer.c:igraph_lgl_yy_init_buffer:
1686| 6.85k|{
1687| 6.85k| int oerrno = errno;
1688| 6.85k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1689| |
1690| 6.85k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 6.85k|#define yy_flush_buffer igraph_lgl_yy_flush_buffer
------------------
1691| |
1692| 6.85k| b->yy_input_file = file;
1693| 6.85k| 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.85k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 6.85k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.85k, False: 0]
| | ------------------
| | 522| 6.85k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.85k| : NULL)
------------------
| Branch (1699:9): [True: 3.42k, False: 3.42k]
------------------
1700| 3.42k| b->yy_bs_lineno = 1;
1701| 3.42k| b->yy_bs_column = 0;
1702| 3.42k| }
1703| |
1704| 6.85k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1704:32): [True: 6.85k, False: 0]
------------------
1705| |
1706| | errno = oerrno;
1707| 6.85k|}
lgl-lexer.c:igraph_lgl_yyensure_buffer_stack:
1795| 3.42k|{
1796| 3.42k| yy_size_t num_to_alloc;
1797| 3.42k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1798| |
1799| 3.42k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1799:6): [True: 3.42k, 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.42k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1806| 3.42k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.42k|#define yyalloc igraph_lgl_yyalloc
------------------
1807| 3.42k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1808| 3.42k| , yyscanner);
1809| 3.42k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1809:8): [True: 0, False: 3.42k]
------------------
1810| 3.42k| 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.42k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1813| |
1814| 3.42k| yyg->yy_buffer_stack_max = num_to_alloc;
1815| 3.42k| yyg->yy_buffer_stack_top = 0;
1816| 3.42k| return;
1817| 3.42k| }
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.85k|{
2185| 6.85k| 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.85k| yyg->yy_buffer_stack = NULL;
2191| 6.85k| yyg->yy_buffer_stack_top = 0;
2192| 6.85k| yyg->yy_buffer_stack_max = 0;
2193| 6.85k| yyg->yy_c_buf_p = NULL;
2194| 6.85k| yyg->yy_init = 0;
2195| 6.85k| yyg->yy_start = 0;
2196| |
2197| 6.85k| yyg->yy_start_stack_ptr = 0;
2198| 6.85k| yyg->yy_start_stack_depth = 0;
2199| 6.85k| 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.85k| yyin = NULL;
------------------
| | 356| 6.85k|#define yyin yyg->yyin_r
------------------
2207| 6.85k| yyout = NULL;
------------------
| | 357| 6.85k|#define yyout yyg->yyout_r
------------------
2208| 6.85k|#endif
2209| |
2210| | /* For future reference: Set errno on error, since we are called by
2211| | * yylex_init()
2212| | */
2213| 6.85k| return 0;
2214| 6.85k|}
igraph_lgl_yyparse:
1189| 3.42k|{
1190| |/* The lookahead symbol. */
1191| 3.42k|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.42k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 358| 3.42k|# define YY_INITIAL_VALUE(Value) Value
------------------
1198| 3.42k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 358| 3.42k|# define YY_INITIAL_VALUE(Value) Value
------------------
1199| |
1200| |/* Location data for the lookahead symbol. */
1201| 3.42k|static YYLTYPE yyloc_default
1202| 3.42k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1203| 3.42k| = { 1, 1, 1, 1 }
1204| 3.42k|# endif
1205| 3.42k|;
1206| 3.42k|YYLTYPE yylloc = yyloc_default;
1207| |
1208| | /* Number of syntax errors so far. */
1209| 3.42k| int yynerrs;
1210| |
1211| 3.42k| yy_state_fast_t yystate;
1212| | /* Number of tokens to shift before error messages enabled. */
1213| 3.42k| 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.42k| yy_state_t yyssa[YYINITDEPTH];
1225| 3.42k| yy_state_t *yyss;
1226| 3.42k| yy_state_t *yyssp;
1227| |
1228| | /* The semantic value stack. */
1229| 3.42k| YYSTYPE yyvsa[YYINITDEPTH];
1230| 3.42k| YYSTYPE *yyvs;
1231| 3.42k| YYSTYPE *yyvsp;
1232| |
1233| | /* The location stack. */
1234| 3.42k| YYLTYPE yylsa[YYINITDEPTH];
1235| 3.42k| YYLTYPE *yyls;
1236| 3.42k| YYLTYPE *yylsp;
1237| |
1238| | /* The locations where the error started and ended. */
1239| 3.42k| YYLTYPE yyerror_range[3];
1240| |
1241| 3.42k| YYPTRDIFF_T yystacksize;
------------------
| | 273| 3.42k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1242| |
1243| 3.42k| int yyn;
1244| 3.42k| int yyresult;
1245| | /* Lookahead token as an internal (translated) token number. */
1246| 3.42k| int yytoken = 0;
1247| | /* The variables used to return semantic value and location from the
1248| | action routines. */
1249| 3.42k| YYSTYPE yyval;
1250| 3.42k| YYLTYPE yyloc;
1251| |
1252| 3.42k|#if YYERROR_VERBOSE
1253| | /* Buffer for error messages, and its allocated size. */
1254| 3.42k| char yymsgbuf[128];
1255| 3.42k| char *yymsg = yymsgbuf;
1256| 3.42k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 273| 3.42k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1257| 3.42k|#endif
1258| |
1259| 3.42k|#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.42k| int yylen = 0;
1264| |
1265| 3.42k| yyssp = yyss = yyssa;
1266| 3.42k| yyvsp = yyvs = yyvsa;
1267| 3.42k| yylsp = yyls = yylsa;
1268| 3.42k| yystacksize = YYINITDEPTH;
------------------
| | 914| 3.42k|# define YYINITDEPTH 200
------------------
1269| |
1270| 3.42k| YYDPRINTF ((stderr, "Starting parse\n"));
1271| |
1272| 3.42k| yystate = 0;
1273| 3.42k| yyerrstatus = 0;
1274| 3.42k| yynerrs = 0;
------------------
| | 71| 3.42k|#define yynerrs igraph_lgl_yynerrs
------------------
1275| 3.42k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 678| 3.42k|#define YYEMPTY (-2)
------------------
1276| 3.42k| yylsp[0] = yylloc;
1277| 3.42k| goto yysetstate;
1278| |
1279| |
1280| |/*------------------------------------------------------------.
1281| || yynewstate -- push a new state, which is found in yystate. |
1282| |`------------------------------------------------------------*/
1283| 1.66M|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| 1.66M| yyssp++;
1287| |
1288| |
1289| |/*--------------------------------------------------------------------.
1290| || yysetstate -- set current state (the top of the stack) to yystate. |
1291| |`--------------------------------------------------------------------*/
1292| 1.66M|yysetstate:
1293| 1.66M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1294| 1.66M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 381| 1.66M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (381:31): [Folded, False: 1.66M]
| | | Branch (381:37): [True: 0, False: 0]
| | | Branch (381:37): [True: 0, False: 0]
| | ------------------
------------------
1295| 1.66M| YY_IGNORE_USELESS_CAST_BEGIN
1296| 1.66M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 124| 1.66M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1297| 1.66M| YY_IGNORE_USELESS_CAST_END
1298| |
1299| 1.66M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1299:7): [True: 0, False: 1.66M]
------------------
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| 1.66M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1366| |
1367| 1.66M| if (yystate == YYFINAL)
------------------
| | 515| 1.66M|#define YYFINAL 2
------------------
| Branch (1367:7): [True: 3.42k, False: 1.66M]
------------------
1368| 3.42k| YYACCEPT;
------------------
| | 681| 3.42k|#define YYACCEPT goto yyacceptlab
------------------
1369| |
1370| 1.66M| goto yybackup;
1371| |
1372| |
1373| |/*-----------.
1374| || yybackup. |
1375| |`-----------*/
1376| 1.66M|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| 1.66M| yyn = yypact[yystate];
1382| 1.66M| if (yypact_value_is_default (yyn))
------------------
| | 602| 1.66M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 599| 1.66M|#define YYPACT_NINF (-3)
| | ------------------
| | | Branch (602:3): [True: 971k, False: 693k]
| | ------------------
------------------
1383| 971k| 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| 693k| if (yychar == YYEMPTY)
------------------
| | 678| 693k|#define YYEMPTY (-2)
------------------
| Branch (1388:7): [True: 680k, False: 12.9k]
------------------
1389| 680k| {
1390| 680k| YYDPRINTF ((stderr, "Reading a token: "));
1391| 680k| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 680k|#define yylex igraph_lgl_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 115| 680k|#define scanner context->scanner
------------------
1392| 680k| }
1393| |
1394| 693k| if (yychar <= YYEOF)
------------------
| | 679| 693k|#define YYEOF 0
------------------
| Branch (1394:7): [True: 5.88k, False: 687k]
------------------
1395| 5.88k| {
1396| 5.88k| yychar = yytoken = YYEOF;
------------------
| | 679| 5.88k|#define YYEOF 0
------------------
1397| 5.88k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1398| 5.88k| }
1399| 687k| else
1400| 687k| {
1401| 687k| yytoken = YYTRANSLATE (yychar);
------------------
| | 535| 687k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 687k|#define YYMAXUTOK 261
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 687k, False: 0]
| | | Branch (535:18): [True: 687k, False: 0]
| | ------------------
------------------
1402| 687k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1403| 687k| }
1404| |
1405| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1406| | detect an error, take that action. */
1407| 693k| yyn += yytoken;
1408| 693k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 517| 693k|#define YYLAST 10
------------------
| Branch (1408:7): [True: 0, False: 693k]
| Branch (1408:18): [True: 0, False: 693k]
| Branch (1408:34): [True: 12.9k, False: 680k]
------------------
1409| 12.9k| goto yydefault;
1410| 680k| yyn = yytable[yyn];
1411| 680k| if (yyn <= 0)
------------------
| Branch (1411:7): [True: 0, False: 680k]
------------------
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| 680k| if (yyerrstatus)
------------------
| Branch (1421:7): [True: 0, False: 680k]
------------------
1422| 0| yyerrstatus--;
1423| |
1424| | /* Shift the lookahead token. */
1425| 680k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1426| 680k| yystate = yyn;
1427| 680k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1428| 680k| *++yyvsp = yylval;
1429| 680k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1430| 680k| *++yylsp = yylloc;
1431| |
1432| | /* Discard the shifted token. */
1433| 680k| yychar = YYEMPTY;
------------------
| | 678| 680k|#define YYEMPTY (-2)
------------------
1434| 680k| goto yynewstate;
1435| |
1436| |
1437| |/*-----------------------------------------------------------.
1438| || yydefault -- do the default action for the current state. |
1439| |`-----------------------------------------------------------*/
1440| 984k|yydefault:
1441| 984k| yyn = yydefact[yystate];
1442| 984k| if (yyn == 0)
------------------
| Branch (1442:7): [True: 0, False: 984k]
------------------
1443| 0| goto yyerrlab;
1444| 984k| goto yyreduce;
1445| |
1446| |
1447| |/*-----------------------------.
1448| || yyreduce -- do a reduction. |
1449| |`-----------------------------*/
1450| 984k|yyreduce:
1451| | /* yyn is the number of a rule to reduce with. */
1452| 984k| 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| 984k| yyval = yyvsp[1-yylen];
1463| |
1464| | /* Default location. */
1465| 984k| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 716| 984k| do \
| | 717| 984k| if (N) \
| | ------------------
| | | Branch (717:11): [True: 968k, False: 16.4k]
| | ------------------
| | 718| 984k| { \
| | 719| 968k| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 734| 968k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 720| 968k| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 734| 968k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 721| 968k| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 734| 968k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 722| 968k| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 734| 968k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 723| 968k| } \
| | 724| 984k| else \
| | 725| 984k| { \
| | 726| 16.4k| (Current).first_line = (Current).last_line = \
| | 727| 16.4k| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 734| 16.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 728| 16.4k| (Current).first_column = (Current).last_column = \
| | 729| 16.4k| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 734| 16.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 730| 16.4k| } \
| | 731| 984k| while (0)
| | ------------------
| | | Branch (731:12): [Folded, False: 984k]
| | ------------------
------------------
1466| 984k| yyerror_range[1] = yyloc;
1467| 984k| YY_REDUCE_PRINT (yyn);
1468| 984k| switch (yyn)
1469| 984k| {
1470| 12.9k| case 6:
------------------
| Branch (1470:3): [True: 12.9k, False: 971k]
------------------
1471| 12.9k|#line 99 "/src/igraph/src/io/lgl-parser.y"
1472| 12.9k| { context->actvertex=(yyvsp[-1].edgenum); }
1473| 12.9k|#line 1474 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1474| 12.9k| break;
1475| |
1476| 195k| case 9:
------------------
| Branch (1476:3): [True: 195k, False: 788k]
------------------
1477| 195k|#line 103 "/src/igraph/src/io/lgl-parser.y"
1478| 195k| {
1479| 195k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, context->actvertex));
------------------
| | 10| 195k| do { \
| | 11| 195k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 195k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 195k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 195k]
| | | | ------------------
| | ------------------
| | 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| 195k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 195k]
| | ------------------
------------------
1480| 195k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-1].edgenum)));
------------------
| | 10| 195k| do { \
| | 11| 195k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 195k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 195k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 195k]
| | | | ------------------
| | ------------------
| | 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| 195k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 195k]
| | ------------------
------------------
1481| 195k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, 1.0));
------------------
| | 10| 195k| do { \
| | 11| 195k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 195k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 195k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 195k]
| | | | ------------------
| | ------------------
| | 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| 195k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 195k]
| | ------------------
------------------
1482| 195k| }
1483| 195k|#line 1484 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1484| 195k| break;
1485| |
1486| 195k| case 10:
------------------
| Branch (1486:3): [True: 82.2k, False: 902k]
------------------
1487| 82.2k|#line 108 "/src/igraph/src/io/lgl-parser.y"
1488| 82.2k| {
1489| 82.2k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, context->actvertex));
------------------
| | 10| 82.2k| do { \
| | 11| 82.2k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 82.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 82.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.2k]
| | | | ------------------
| | ------------------
| | 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| 82.2k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 82.2k]
| | ------------------
------------------
1490| 82.2k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-2].edgenum)));
------------------
| | 10| 82.2k| do { \
| | 11| 82.2k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 82.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 82.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.2k]
| | | | ------------------
| | ------------------
| | 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| 82.2k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 82.2k]
| | ------------------
------------------
1491| 82.2k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, (yyvsp[-1].weightnum)));
------------------
| | 10| 82.2k| do { \
| | 11| 82.2k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 82.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 82.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.2k]
| | | | ------------------
| | ------------------
| | 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| 82.2k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 82.2k]
| | ------------------
------------------
1492| 82.2k| context->has_weights = 1;
1493| 82.2k| }
1494| 0|#line 1495 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1495| 0| break;
1496| |
1497| 291k| case 11:
------------------
| Branch (1497:3): [True: 291k, False: 693k]
------------------
1498| 291k|#line 117 "/src/igraph/src/io/lgl-parser.y"
1499| 291k| {
1500| 291k| igraph_int_t trie_id;
1501| 291k| IGRAPH_YY_CHECK(igraph_trie_get_len(context->trie,
------------------
| | 10| 291k| do { \
| | 11| 291k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 291k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 291k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 291k]
| | | | ------------------
| | ------------------
| | 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| 291k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 291k]
| | ------------------
------------------
1502| 291k| igraph_lgl_yyget_text(scanner),
1503| 291k| igraph_lgl_yyget_leng(scanner),
1504| 291k| &trie_id
1505| 291k| ));
1506| 291k| (yyval.edgenum) = trie_id;
1507| 291k|}
1508| 0|#line 1509 "/src/igraph/build/src/io/parsers/lgl-parser.c"
1509| 0| break;
1510| |
1511| 82.2k| case 12:
------------------
| Branch (1511:3): [True: 82.2k, False: 902k]
------------------
1512| 82.2k|#line 127 "/src/igraph/src/io/lgl-parser.y"
1513| 82.2k| {
1514| 82.2k| igraph_real_t val;
1515| 82.2k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_lgl_yyget_text(scanner),
------------------
| | 10| 82.2k| do { \
| | 11| 82.2k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 82.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 82.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.2k]
| | | | ------------------
| | ------------------
| | 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| 82.2k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 82.2k]
| | ------------------
------------------
1516| 82.2k| igraph_lgl_yyget_leng(scanner),
1517| 82.2k| &val));
1518| 82.2k| (yyval.weightnum)=val;
1519| 82.2k|}
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| 320k| default: break;
------------------
| Branch (1526:7): [True: 320k, False: 664k]
------------------
1527| 984k| }
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| 984k| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1540| |
1541| 984k| YYPOPSTACK (yylen);
------------------
| | 1259| 984k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1542| 984k| yylen = 0;
1543| 984k| YY_STACK_PRINT (yyss, yyssp);
1544| |
1545| 984k| *++yyvsp = yyval;
1546| 984k| *++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| 984k| {
1552| 984k| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 520| 984k|#define YYNTOKENS 7
------------------
1553| 984k| const int yyi = yypgoto[yylhs] + *yyssp;
1554| 984k| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 517| 1.92M|#define YYLAST 10
------------------
| Branch (1554:16): [True: 942k, False: 42.3k]
| Branch (1554:28): [True: 942k, False: 0]
| Branch (1554:45): [True: 278k, False: 664k]
------------------
1555| 984k| ? yytable[yyi]
1556| 984k| : yydefgoto[yylhs]);
1557| 984k| }
1558| |
1559| 984k| 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.42k|yyacceptlab:
1707| 3.42k| yyresult = 0;
1708| 3.42k| 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.42k|yyreturn:
1734| 3.42k| if (yychar != YYEMPTY)
------------------
| | 678| 3.42k|#define YYEMPTY (-2)
------------------
| Branch (1734:7): [True: 0, False: 3.42k]
------------------
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.42k| YYPOPSTACK (yylen);
------------------
| | 1259| 3.42k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1745| 3.42k| YY_STACK_PRINT (yyss, yyssp);
1746| 10.2k| while (yyssp != yyss)
------------------
| Branch (1746:10): [True: 6.85k, False: 3.42k]
------------------
1747| 6.85k| {
1748| 6.85k| yydestruct ("Cleanup: popping",
1749| 6.85k| yystos[+*yyssp], yyvsp, yylsp, context);
1750| 6.85k| YYPOPSTACK (1);
------------------
| | 1259| 6.85k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1751| 6.85k| }
1752| 3.42k|#ifndef yyoverflow
1753| 3.42k| if (yyss != yyssa)
------------------
| Branch (1753:7): [True: 0, False: 3.42k]
------------------
1754| 0| YYSTACK_FREE (yyss);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1755| 3.42k|#endif
1756| 3.42k|#if YYERROR_VERBOSE
1757| 3.42k| if (yymsg != yymsgbuf)
------------------
| Branch (1757:7): [True: 0, False: 3.42k]
------------------
1758| 0| YYSTACK_FREE (yymsg);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1759| 3.42k|#endif
1760| 3.42k| return yyresult;
1761| 0|}
lgl-parser.c:yydestruct:
1167| 6.85k|{
1168| 6.85k| YYUSE (yyvaluep);
------------------
| | 344| 6.85k|# define YYUSE(E) ((void) (E))
------------------
1169| 6.85k| YYUSE (yylocationp);
------------------
| | 344| 6.85k|# define YYUSE(E) ((void) (E))
------------------
1170| 6.85k| YYUSE (context);
------------------
| | 344| 6.85k|# define YYUSE(E) ((void) (E))
------------------
1171| 6.85k| if (!yymsg)
------------------
| Branch (1171:7): [True: 0, False: 6.85k]
------------------
1172| 0| yymsg = "Deleting";
1173| 6.85k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1174| |
1175| 6.85k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1176| 6.85k| YYUSE (yytype);
------------------
| | 344| 6.85k|# define YYUSE(E) ((void) (E))
------------------
1177| 6.85k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1178| 6.85k|}
igraph_ncol_yylex:
994| 923k|{
995| 923k| yy_state_type yy_current_state;
996| 923k| char *yy_cp, *yy_bp;
997| 923k| int yy_act;
998| 923k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
999| |
1000| 923k| yylval = yylval_param;
------------------
| | 807| 923k| # define yylval yyg->yylval_r
------------------
1001| |
1002| 923k| yylloc = yylloc_param;
------------------
| | 809| 923k| # define yylloc yyg->yylloc_r
------------------
1003| |
1004| 923k| if ( !yyg->yy_init )
------------------
| Branch (1004:7): [True: 3.47k, False: 919k]
------------------
1005| 3.47k| {
1006| 3.47k| yyg->yy_init = 1;
1007| |
1008| |#ifdef YY_USER_INIT
1009| | YY_USER_INIT;
1010| |#endif
1011| |
1012| 3.47k| if ( ! yyg->yy_start )
------------------
| Branch (1012:8): [True: 3.47k, False: 0]
------------------
1013| 3.47k| yyg->yy_start = 1; /* first start state */
1014| |
1015| 3.47k| if ( ! yyin )
------------------
| | 356| 3.47k|#define yyin yyg->yyin_r
------------------
| Branch (1015:8): [True: 0, False: 3.47k]
------------------
1016| 0| yyin = stdin;
------------------
| | 356| 0|#define yyin yyg->yyin_r
------------------
1017| |
1018| 3.47k| if ( ! yyout )
------------------
| | 357| 3.47k|#define yyout yyg->yyout_r
------------------
| Branch (1018:8): [True: 3.47k, False: 0]
------------------
1019| 3.47k| yyout = stdout;
------------------
| | 357| 3.47k|#define yyout yyg->yyout_r
------------------
1020| |
1021| 3.47k| if ( ! YY_CURRENT_BUFFER ) {
------------------
| | 521| 3.47k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 0, False: 3.47k]
| | ------------------
| | 522| 3.47k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.47k| : NULL)
------------------
| Branch (1021:8): [True: 3.47k, False: 0]
------------------
1022| 3.47k| yyensure_buffer_stack (yyscanner);
------------------
| | 86| 3.47k|#define yyensure_buffer_stack igraph_ncol_yyensure_buffer_stack
------------------
1023| 3.47k| YY_CURRENT_BUFFER_LVALUE =
------------------
| | 527| 3.47k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1024| 3.47k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 20| 3.47k|#define yy_create_buffer igraph_ncol_yy_create_buffer
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 356| 3.47k|#define yyin yyg->yyin_r
------------------
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
------------------
| | 391| 3.47k|#define YY_BUF_SIZE 16384
------------------
1025| 3.47k| }
1026| |
1027| 3.47k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.47k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1028| 3.47k| }
1029| |
1030| 923k| {
1031| 923k|#line 79 "/src/igraph/src/io/ncol-lexer.l"
1032| |
1033| |
1034| 923k|#line 82 "/src/igraph/src/io/ncol-lexer.l"
1035| | /* ------------------------------------------------whitespace------*/
1036| 923k|#line 1037 "/src/igraph/build/src/io/parsers/ncol-lexer.c"
1037| |
1038| 1.28M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
------------------
| Branch (1038:23): [True: 1.28M, Folded]
------------------
1039| 1.28M| {
1040| 1.28M| yy_cp = yyg->yy_c_buf_p;
1041| |
1042| | /* Support of yytext. */
1043| 1.28M| *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.28M| yy_bp = yy_cp;
1049| |
1050| 1.28M| yy_current_state = yyg->yy_start;
1051| 1.29M|yy_match:
1052| 1.29M| do
1053| 62.4M| {
1054| 62.4M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
------------------
| | 346| 62.4M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
1055| 62.4M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1055:9): [True: 61.1M, False: 1.28M]
------------------
1056| 61.1M| {
1057| 61.1M| yyg->yy_last_accepting_state = yy_current_state;
1058| 61.1M| yyg->yy_last_accepting_cpos = yy_cp;
1059| 61.1M| }
1060| 125M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1060:12): [True: 63.4M, False: 62.4M]
------------------
1061| 63.4M| {
1062| 63.4M| yy_current_state = (int) yy_def[yy_current_state];
1063| 63.4M| if ( yy_current_state >= 15 )
------------------
| Branch (1063:10): [True: 61.1M, False: 2.29M]
------------------
1064| 61.1M| yy_c = yy_meta[yy_c];
1065| 63.4M| }
1066| 62.4M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1067| 62.4M| ++yy_cp;
1068| 62.4M| }
1069| 62.4M| while ( yy_base[yy_current_state] != 11 );
------------------
| Branch (1069:11): [True: 61.1M, False: 1.29M]
------------------
1070| |
1071| 1.29M|yy_find_action:
1072| 1.29M| yy_act = yy_accept[yy_current_state];
1073| 1.29M| if ( yy_act == 0 )
------------------
| Branch (1073:8): [True: 1.29M, False: 2.51k]
------------------
1074| 1.29M| { /* have to back up */
1075| 1.29M| yy_cp = yyg->yy_last_accepting_cpos;
1076| 1.29M| yy_current_state = yyg->yy_last_accepting_state;
1077| 1.29M| yy_act = yy_accept[yy_current_state];
1078| 1.29M| }
1079| |
1080| 1.29M| YY_DO_BEFORE_ACTION;
------------------
| | 590| 1.29M| yyg->yytext_ptr = yy_bp; \
| | ------------------
| | | | 579| 1.29M|#define yytext_ptr yytext_r
| | ------------------
| | 591| 1.29M| yyleng = (int) (yy_cp - yy_bp); \
| | ------------------
| | | | 359| 1.29M|#define yyleng yyg->yyleng_r
| | ------------------
| | 592| 1.29M| yyg->yy_hold_char = *yy_cp; \
| | 593| 1.29M| *yy_cp = '\0'; \
| | 594| 1.29M| yyg->yy_c_buf_p = yy_cp;
------------------
1081| |
1082| 1.29M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
------------------
| | 596| 2.59M|#define YY_END_OF_BUFFER 6
------------------
| Branch (1082:8): [True: 1.28M, False: 16.2k]
| Branch (1082:38): [True: 279k, False: 1.00M]
------------------
1083| 279k| {
1084| 279k| int yyl;
1085| 558k| for ( yyl = 0; yyl < yyleng; ++yyl )
------------------
| | 359| 558k|#define yyleng yyg->yyleng_r
------------------
| Branch (1085:19): [True: 279k, False: 279k]
------------------
1086| 279k| if ( yytext[yyl] == '\n' )
------------------
| | 360| 279k|#define yytext yyg->yytext_r
------------------
| Branch (1086:10): [True: 279k, False: 0]
------------------
1087| |
1088| 279k| do{ yylineno++;
------------------
| | 361| 279k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | ------------------
| | | | 527| 279k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1089| 279k| yycolumn=0;
------------------
| | 362| 279k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
| | ------------------
| | | | 527| 279k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
------------------
1090| 279k| }while(0)
------------------
| Branch (1090:12): [Folded, False: 279k]
------------------
1091| 279k|;
1092| 279k| }
1093| |
1094| 1.30M|do_action: /* This label is used only to access EOF actions. */
1095| |
1096| 1.30M| switch ( yy_act )
1097| 1.30M| { /* beginning of action switch */
1098| 0| case 0: /* must back up */
------------------
| Branch (1098:4): [True: 0, False: 1.30M]
------------------
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| 361k|case 1:
------------------
| Branch (1105:1): [True: 361k, False: 939k]
------------------
1106| 361k|YY_RULE_SETUP
------------------
| | 989| 361k| YY_USER_ACTION
| | ------------------
| | | | 735| 361k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 361k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 361k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 361k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1107| 361k|#line 83 "/src/igraph/src/io/ncol-lexer.l"
1108| 361k|{ /* skip space */ }
1109| 361k| YY_BREAK
------------------
| | 985| 361k|#define YY_BREAK /*LINTED*/break;
------------------
1110| |/* ----------------------------------------------alphanumeric------*/
1111| 640k|case 2:
------------------
| Branch (1111:1): [True: 640k, False: 660k]
------------------
1112| 640k|YY_RULE_SETUP
------------------
| | 989| 640k| YY_USER_ACTION
| | ------------------
| | | | 735| 640k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 640k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 640k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 640k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1113| 640k|#line 86 "/src/igraph/src/io/ncol-lexer.l"
1114| 640k|{ BEGIN(LINE); return ALNUM; }
------------------
| | 369| 640k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(LINE); return ALNUM; }
------------------
| | 751| 640k|#define LINE 1
------------------
1115| 0| YY_BREAK
------------------
| | 985| 0|#define YY_BREAK /*LINTED*/break;
------------------
1116| |/* ---------------------------------------------------newline------*/
1117| 279k|case 3:
------------------
| Branch (1117:1): [True: 279k, False: 1.02M]
------------------
1118| |/* rule 3 can match eol */
1119| 279k|#line 90 "/src/igraph/src/io/ncol-lexer.l"
1120| 279k|YY_RULE_SETUP
------------------
| | 989| 279k| YY_USER_ACTION
| | ------------------
| | | | 735| 279k|#define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 809| 279k| # define yylloc yyg->yylloc_r
| | | | ------------------
| | | | #define YY_USER_ACTION yylloc->first_line = yylineno;
| | | | ------------------
| | | | | | 361| 279k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
| | | | | | ------------------
| | | | | | | | 527| 279k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | | | | | ------------------
| | | | ------------------
| | ------------------
------------------
1121| 279k|case YY_STATE_EOF(LINE):
------------------
| | 377| 279k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 279k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
| Branch (1121:1): [True: 0, False: 1.30M]
------------------
1122| 279k|#line 90 "/src/igraph/src/io/ncol-lexer.l"
1123| 279k|{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 369| 279k|#define BEGIN yyg->yy_start = 1 + 2 *
------------------
{ BEGIN(INITIAL); return NEWLINE; }
------------------
| | 750| 279k|#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.30M]
------------------
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.30M]
------------------
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.47k|case YY_STATE_EOF(INITIAL):
------------------
| | 377| 3.47k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.47k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
| Branch (1137:1): [True: 3.47k, False: 1.29M]
------------------
1138| 3.47k| yyterminate();
------------------
| | 948| 3.47k|#define yyterminate() return YY_NULL
| | ------------------
| | | | 341| 3.47k|#define YY_NULL 0
| | ------------------
------------------
1139| |
1140| 16.2k| case YY_END_OF_BUFFER:
------------------
| | 596| 16.2k|#define YY_END_OF_BUFFER 6
------------------
| Branch (1140:2): [True: 16.2k, False: 1.28M]
------------------
1141| 16.2k| {
1142| | /* Amount of text matched not including the EOB char. */
1143| 16.2k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
------------------
| | 579| 16.2k|#define yytext_ptr yytext_r
------------------
1144| |
1145| | /* Undo the effects of YY_DO_BEFORE_ACTION. */
1146| 16.2k| *yy_cp = yyg->yy_hold_char;
1147| 16.2k| YY_RESTORE_YY_MORE_OFFSET
1148| |
1149| 16.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
------------------
| | 498| 16.2k|#define YY_BUFFER_NEW 0
------------------
| Branch (1149:8): [True: 3.47k, False: 12.7k]
------------------
1150| 3.47k| {
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.47k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 3.47k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1161| 3.47k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 527| 3.47k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
------------------
| | 356| 3.47k|#define yyin yyg->yyin_r
------------------
1162| 3.47k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
------------------
| | 527| 3.47k|#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.47k|#define YY_BUFFER_NORMAL 1
------------------
1163| 3.47k| }
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.2k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1172:8): [True: 0, False: 16.2k]
------------------
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.2k| else switch ( yy_get_next_buffer( yyscanner ) )
------------------
| Branch (1208:17): [True: 16.2k, False: 0]
------------------
1209| 16.2k| {
1210| 3.47k| case EOB_ACT_END_OF_FILE:
------------------
| | 410| 3.47k|#define EOB_ACT_END_OF_FILE 1
------------------
| Branch (1210:4): [True: 3.47k, False: 12.7k]
------------------
1211| 3.47k| {
1212| 3.47k| yyg->yy_did_buffer_switch_on_eof = 0;
1213| |
1214| 3.47k| if ( yywrap( yyscanner ) )
------------------
| | 206| 3.47k|#define yywrap igraph_ncol_yywrap
| | ------------------
| | | | 573| 3.47k|#define igraph_ncol_yywrap(yyscanner) (/*CONSTCOND*/1)
| | | | ------------------
| | | | | Branch (573:39): [True: 3.47k, Folded]
| | | | ------------------
| | ------------------
------------------
1215| 3.47k| {
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.47k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 3.47k|#define yytext_ptr yytext_r
------------------
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 3.47k|#define YY_MORE_ADJ 0
------------------
1226| |
1227| 3.47k| yy_act = YY_STATE_EOF(YY_START);
------------------
| | 377| 3.47k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
| | ------------------
| | | | 596| 3.47k|#define YY_END_OF_BUFFER 6
| | ------------------
------------------
1228| 3.47k| goto do_action;
1229| 3.47k| }
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.47k| }
1238| |
1239| 10.2k| case EOB_ACT_CONTINUE_SCAN:
------------------
| | 409| 10.2k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
| Branch (1239:4): [True: 10.2k, False: 5.98k]
------------------
1240| 10.2k| yyg->yy_c_buf_p =
1241| 10.2k| yyg->yytext_ptr + yy_amount_of_matched_text;
------------------
| | 579| 10.2k|#define yytext_ptr yytext_r
------------------
1242| |
1243| 10.2k| yy_current_state = yy_get_previous_state( yyscanner );
1244| |
1245| 10.2k| yy_cp = yyg->yy_c_buf_p;
1246| 10.2k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 10.2k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 10.2k|#define YY_MORE_ADJ 0
------------------
1247| 10.2k| goto yy_match;
1248| |
1249| 2.51k| case EOB_ACT_LAST_MATCH:
------------------
| | 411| 2.51k|#define EOB_ACT_LAST_MATCH 2
------------------
| Branch (1249:4): [True: 2.51k, False: 13.7k]
------------------
1250| 2.51k| yyg->yy_c_buf_p =
1251| 2.51k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
------------------
| | 527| 2.51k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1252| |
1253| 2.51k| yy_current_state = yy_get_previous_state( yyscanner );
1254| |
1255| 2.51k| yy_cp = yyg->yy_c_buf_p;
1256| 2.51k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 579| 2.51k|#define yytext_ptr yytext_r
------------------
yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
------------------
| | 681| 2.51k|#define YY_MORE_ADJ 0
------------------
1257| 2.51k| goto yy_find_action;
1258| 16.2k| }
1259| 0| break;
1260| 16.2k| }
1261| |
1262| 0| default:
------------------
| Branch (1262:2): [True: 0, False: 1.30M]
------------------
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.30M| "fatal flex scanner internal error--no action found" );
1265| 1.30M| } /* end of action switch */
1266| 1.30M| } /* end of scanning one token */
1267| 923k| } /* end of user's declarations */
1268| 923k|} /* end of yylex */
igraph_ncol_yyrestart:
1566| 3.47k|{
1567| 3.47k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1568| |
1569| 3.47k| if ( ! YY_CURRENT_BUFFER ){
------------------
| | 521| 3.47k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.47k, False: 0]
| | ------------------
| | 522| 3.47k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.47k| : NULL)
------------------
| Branch (1569:7): [True: 0, False: 3.47k]
------------------
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.47k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 50| 3.47k|#define yy_init_buffer igraph_ncol_yy_init_buffer
------------------
yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
------------------
| | 521| 3.47k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.47k, False: 0]
| | ------------------
| | 522| 3.47k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.47k| : NULL)
------------------
1576| 3.47k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.47k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1577| 3.47k|}
igraph_ncol_yy_create_buffer:
1631| 3.47k|{
1632| 3.47k| YY_BUFFER_STATE b;
1633| |
1634| 3.47k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
------------------
| | 236| 3.47k|#define yyalloc igraph_ncol_yyalloc
------------------
1635| 3.47k| if ( ! b )
------------------
| Branch (1635:7): [True: 0, False: 3.47k]
------------------
1636| 3.47k| 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.47k| 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.47k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
------------------
| | 236| 3.47k|#define yyalloc igraph_ncol_yyalloc
------------------
1644| 3.47k| if ( ! b->yy_ch_buf )
------------------
| Branch (1644:7): [True: 0, False: 3.47k]
------------------
1645| 3.47k| 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.47k| b->yy_is_our_buffer = 1;
1648| |
1649| 3.47k| yy_init_buffer( b, file , yyscanner);
------------------
| | 50| 3.47k|#define yy_init_buffer igraph_ncol_yy_init_buffer
------------------
1650| |
1651| 3.47k| return b;
1652| 3.47k|}
igraph_ncol_yy_delete_buffer:
1659| 3.47k|{
1660| 3.47k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1661| |
1662| 3.47k| if ( ! b )
------------------
| Branch (1662:7): [True: 0, False: 3.47k]
------------------
1663| 0| return;
1664| |
1665| 3.47k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
------------------
| | 521| 3.47k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.47k, False: 0]
| | ------------------
| | 522| 3.47k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.47k| : NULL)
------------------
| Branch (1665:7): [True: 3.47k, False: 0]
------------------
1666| 3.47k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
------------------
| | 527| 3.47k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1667| |
1668| 3.47k| if ( b->yy_is_our_buffer )
------------------
| Branch (1668:7): [True: 3.47k, False: 0]
------------------
1669| 3.47k| yyfree( (void *) b->yy_ch_buf , yyscanner );
------------------
| | 248| 3.47k|#define yyfree igraph_ncol_yyfree
------------------
1670| |
1671| 3.47k| yyfree( (void *) b , yyscanner );
------------------
| | 248| 3.47k|#define yyfree igraph_ncol_yyfree
------------------
1672| 3.47k|}
igraph_ncol_yy_flush_buffer:
1708| 6.95k|{
1709| 6.95k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1710| 6.95k| if ( ! b )
------------------
| Branch (1710:7): [True: 0, False: 6.95k]
------------------
1711| 0| return;
1712| |
1713| 6.95k| 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.95k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.95k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1720| 6.95k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 6.95k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1721| |
1722| 6.95k| b->yy_buf_pos = &b->yy_ch_buf[0];
1723| |
1724| 6.95k| b->yy_at_bol = 1;
1725| 6.95k| b->yy_buffer_status = YY_BUFFER_NEW;
------------------
| | 498| 6.95k|#define YY_BUFFER_NEW 0
------------------
1726| |
1727| 6.95k| if ( b == YY_CURRENT_BUFFER )
------------------
| | 521| 6.95k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.95k, False: 0]
| | ------------------
| | 522| 6.95k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.95k| : NULL)
------------------
| Branch (1727:7): [True: 3.47k, False: 3.47k]
------------------
1728| 3.47k| yy_load_buffer_state( yyscanner );
------------------
| | 62| 3.47k|#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
------------------
1729| 6.95k|}
igraph_ncol_yypop_buffer_state:
1769| 3.47k|{
1770| 3.47k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1771| 3.47k| if (!YY_CURRENT_BUFFER)
------------------
| | 521| 3.47k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.47k, False: 0]
| | ------------------
| | 522| 3.47k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.47k| : NULL)
------------------
| Branch (1771:6): [True: 3.47k, False: 0]
------------------
1772| 3.47k| 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| 640k|{
2007| 640k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2008| 640k| return yyleng;
------------------
| | 359| 640k|#define yyleng yyg->yyleng_r
------------------
2009| 640k|}
igraph_ncol_yyget_text:
2016| 640k|{
2017| 640k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2018| 640k| return yytext;
------------------
| | 360| 640k|#define yytext yyg->yytext_r
------------------
2019| 640k|}
igraph_ncol_yyset_extra:
2026| 6.95k|{
2027| 6.95k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2028| 6.95k| yyextra = user_defined ;
------------------
| | 358| 6.95k|#define yyextra yyg->yyextra_r
------------------
2029| 6.95k|}
igraph_ncol_yyset_in:
2068| 3.47k|{
2069| 3.47k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2070| 3.47k| yyin = _in_str ;
------------------
| | 356| 3.47k|#define yyin yyg->yyin_r
------------------
2071| 3.47k|}
igraph_ncol_yylex_init_extra:
2151| 3.47k|{
2152| 3.47k| struct yyguts_t dummy_yyguts;
2153| |
2154| 3.47k| yyset_extra (yy_user_defined, &dummy_yyguts);
------------------
| | 140| 3.47k|#define yyset_extra igraph_ncol_yyset_extra
------------------
2155| |
2156| 3.47k| if (ptr_yy_globals == NULL){
------------------
| Branch (2156:9): [True: 0, False: 3.47k]
------------------
2157| 0| errno = EINVAL;
2158| 0| return 1;
2159| 0| }
2160| |
2161| 3.47k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
------------------
| | 236| 3.47k|#define yyalloc igraph_ncol_yyalloc
------------------
2162| |
2163| 3.47k| if (*ptr_yy_globals == NULL){
------------------
| Branch (2163:9): [True: 0, False: 3.47k]
------------------
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.47k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2171| |
2172| 3.47k| yyset_extra (yy_user_defined, *ptr_yy_globals);
------------------
| | 140| 3.47k|#define yyset_extra igraph_ncol_yyset_extra
------------------
2173| |
2174| 3.47k| return yy_init_globals ( *ptr_yy_globals );
2175| 3.47k|}
igraph_ncol_yylex_destroy:
2212| 3.47k|{
2213| 3.47k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2214| |
2215| | /* Pop the buffer stack, destroying each element. */
2216| 6.95k| while(YY_CURRENT_BUFFER){
------------------
| | 521| 6.95k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:27): [True: 3.47k, False: 3.47k]
| | | Branch (521:29): [True: 6.95k, False: 0]
| | ------------------
| | 522| 6.95k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.95k| : NULL)
------------------
2217| 3.47k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 26| 3.47k|#define yy_delete_buffer igraph_ncol_yy_delete_buffer
------------------
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
------------------
| | 521| 3.47k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 3.47k, False: 0]
| | ------------------
| | 522| 3.47k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 3.47k| : NULL)
------------------
2218| 3.47k| YY_CURRENT_BUFFER_LVALUE = NULL;
------------------
| | 527| 3.47k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
2219| 3.47k| yypop_buffer_state(yyscanner);
------------------
| | 80| 3.47k|#define yypop_buffer_state igraph_ncol_yypop_buffer_state
------------------
2220| 3.47k| }
2221| |
2222| | /* Destroy the stack itself. */
2223| 3.47k| yyfree(yyg->yy_buffer_stack , yyscanner);
------------------
| | 248| 3.47k|#define yyfree igraph_ncol_yyfree
------------------
2224| 3.47k| yyg->yy_buffer_stack = NULL;
2225| |
2226| | /* Destroy the start condition stack. */
2227| 3.47k| yyfree( yyg->yy_start_stack , yyscanner );
------------------
| | 248| 3.47k|#define yyfree igraph_ncol_yyfree
------------------
2228| 3.47k| 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.47k| yy_init_globals( yyscanner);
2233| |
2234| | /* Destroy the main struct (reentrant only). */
2235| 3.47k| yyfree ( yyscanner , yyscanner );
------------------
| | 248| 3.47k|#define yyfree igraph_ncol_yyfree
------------------
2236| | yyscanner = NULL;
2237| 3.47k| return 0;
2238| 3.47k|}
igraph_ncol_yyalloc:
2268| 13.9k|{
2269| 13.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2270| 13.9k| (void)yyg;
2271| 13.9k| return malloc(size);
2272| 13.9k|}
igraph_ncol_yyrealloc:
2275| 80|{
2276| 80| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2277| 80| (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| 80| return realloc(ptr, size);
2287| 80|}
igraph_ncol_yyfree:
2290| 17.3k|{
2291| 17.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2292| 17.3k| (void)yyg;
2293| 17.3k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2294| 17.3k|}
ncol-lexer.c:yy_get_next_buffer:
1278| 16.2k|{
1279| 16.2k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1280| 16.2k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1281| 16.2k| char *source = yyg->yytext_ptr;
------------------
| | 579| 16.2k|#define yytext_ptr yytext_r
------------------
1282| 16.2k| int number_to_move, i;
1283| 16.2k| int ret_val;
1284| |
1285| 16.2k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1285:7): [True: 0, False: 16.2k]
------------------
1286| 16.2k| 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.2k| "fatal flex scanner internal error--end of buffer missed" );
1288| |
1289| 16.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1289:7): [True: 0, False: 16.2k]
------------------
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.2k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
------------------
| | 579| 16.2k|#define yytext_ptr yytext_r
------------------
1312| |
1313| 245M| for ( i = 0; i < number_to_move; ++i )
------------------
| Branch (1313:15): [True: 245M, False: 16.2k]
------------------
1314| 245M| *(dest++) = *(source++);
1315| |
1316| 16.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
------------------
| | 510| 16.2k|#define YY_BUFFER_EOF_PENDING 2
------------------
| Branch (1316:7): [True: 2.51k, False: 13.7k]
------------------
1317| | /* don't do the read, it's not guaranteed to return an EOF,
1318| | * just force an EOF
1319| | */
1320| 2.51k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
------------------
| | 527| 2.51k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1321| |
1322| 13.7k| else
1323| 13.7k| {
1324| 13.7k| int num_to_read =
1325| 13.7k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
------------------
| | 527| 13.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1326| |
1327| 13.7k| while ( num_to_read <= 0 )
------------------
| Branch (1327:11): [True: 80, False: 13.7k]
------------------
1328| 80| { /* Not enough room in the buffer - grow it. */
1329| |
1330| | /* just a shorter name for the current buffer */
1331| 80| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
------------------
| | 527| 80|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1332| |
1333| 80| int yy_c_buf_p_offset =
1334| 80| (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1335| |
1336| 80| if ( b->yy_is_our_buffer )
------------------
| Branch (1336:9): [True: 80, False: 0]
------------------
1337| 80| {
1338| 80| int new_size = b->yy_buf_size * 2;
1339| |
1340| 80| if ( new_size <= 0 )
------------------
| Branch (1340:10): [True: 0, False: 80]
------------------
1341| 0| b->yy_buf_size += b->yy_buf_size / 8;
1342| 80| else
1343| 80| b->yy_buf_size *= 2;
1344| |
1345| 80| b->yy_ch_buf = (char *)
1346| | /* Include room in for 2 EOB chars. */
1347| 80| yyrealloc( (void *) b->yy_ch_buf,
------------------
| | 242| 80|#define yyrealloc igraph_ncol_yyrealloc
------------------
1348| 80| (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1349| 80| }
1350| 0| else
1351| | /* Can't grow it, we don't own it. */
1352| 0| b->yy_ch_buf = NULL;
1353| |
1354| 80| if ( ! b->yy_ch_buf )
------------------
| Branch (1354:9): [True: 0, False: 80]
------------------
1355| 80| 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| 80| "fatal error - scanner input buffer overflow" );
1357| |
1358| 80| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1359| |
1360| 80| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
------------------
| | 527| 80|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1361| 80| number_to_move - 1;
1362| |
1363| 80| }
1364| |
1365| 13.7k| if ( num_to_read > YY_READ_BUF_SIZE )
------------------
| | 895| 13.7k|#define YY_READ_BUF_SIZE 8192
------------------
| Branch (1365:8): [True: 12.6k, False: 1.08k]
------------------
1366| 12.6k| num_to_read = YY_READ_BUF_SIZE;
------------------
| | 895| 12.6k|#define YY_READ_BUF_SIZE 8192
------------------
1367| |
1368| | /* Read in more data. */
1369| 13.7k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
------------------
| | 912| 13.7k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
| | ------------------
| | | | 527| 13.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
| | ------------------
| | | Branch (912:7): [True: 0, False: 13.7k]
| | ------------------
| | 913| 13.7k| { \
| | 914| 0| int c = '*'; \
| | 915| 0| int n; \
| | 916| 0| for ( n = 0; n < max_size && \
| | ------------------
| | | Branch (916:16): [True: 0, False: 0]
| | ------------------
| | 917| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (917:9): [True: 0, False: 0]
| | | Branch (917:38): [True: 0, False: 0]
| | ------------------
| | 918| 0| buf[n] = (char) c; \
| | 919| 0| if ( c == '\n' ) \
| | ------------------
| | | Branch (919:8): [True: 0, False: 0]
| | ------------------
| | 920| 0| buf[n++] = (char) c; \
| | 921| 0| if ( c == EOF && ferror( yyin ) ) \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (921:8): [True: 0, False: 0]
| | | Branch (921:20): [True: 0, False: 0]
| | ------------------
| | 922| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \
| | ------------------
| | | | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | | | ------------------
| | | | | | 895| 0| do { \
| | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | | | 897| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (897:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 923| 0| result = n; \
| | 924| 0| } \
| | 925| 13.7k| else \
| | 926| 13.7k| { \
| | 927| 13.7k| errno=0; \
| | 928| 13.7k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 13.7k|#define yyin yyg->yyin_r
| | ------------------
| | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
| | ------------------
| | | | 356| 3.47k|#define yyin yyg->yyin_r
| | ------------------
| | | Branch (928:11): [True: 3.47k, False: 10.2k]
| | | Branch (928:78): [True: 0, False: 3.47k]
| | ------------------
| | 929| 13.7k| { \
| | 930| 0| if( errno != EINTR) \
| | ------------------
| | | Branch (930:8): [True: 0, False: 0]
| | ------------------
| | 931| 0| { \
| | 932| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \
| | ------------------
| | | | 736| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
| | | | ------------------
| | | | | | 895| 0| do { \
| | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | | | | | 897| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (897:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | ------------------
| | 933| 0| break; \
| | 934| 0| } \
| | 935| 0| errno=0; \
| | 936| 0| clearerr(yyin); \
| | ------------------
| | | | 356| 0|#define yyin yyg->yyin_r
| | ------------------
| | 937| 0| } \
| | 938| 13.7k| }\
------------------
1370| 13.7k| yyg->yy_n_chars, num_to_read );
1371| |
1372| 13.7k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
------------------
| | 527| 13.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1373| 13.7k| }
1374| |
1375| 16.2k| if ( yyg->yy_n_chars == 0 )
------------------
| Branch (1375:7): [True: 5.98k, False: 10.2k]
------------------
1376| 5.98k| {
1377| 5.98k| if ( number_to_move == YY_MORE_ADJ )
------------------
| | 681| 5.98k|#define YY_MORE_ADJ 0
------------------
| Branch (1377:8): [True: 3.47k, False: 2.51k]
------------------
1378| 3.47k| {
1379| 3.47k| ret_val = EOB_ACT_END_OF_FILE;
------------------
| | 410| 3.47k|#define EOB_ACT_END_OF_FILE 1
------------------
1380| 3.47k| yyrestart( yyin , yyscanner);
------------------
| | 98| 3.47k|#define yyrestart igraph_ncol_yyrestart
------------------
yyrestart( yyin , yyscanner);
------------------
| | 356| 3.47k|#define yyin yyg->yyin_r
------------------
1381| 3.47k| }
1382| |
1383| 2.51k| else
1384| 2.51k| {
1385| 2.51k| ret_val = EOB_ACT_LAST_MATCH;
------------------
| | 411| 2.51k|#define EOB_ACT_LAST_MATCH 2
------------------
1386| 2.51k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
------------------
| | 527| 2.51k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1387| 2.51k| YY_BUFFER_EOF_PENDING;
------------------
| | 510| 2.51k|#define YY_BUFFER_EOF_PENDING 2
------------------
1388| 2.51k| }
1389| 5.98k| }
1390| |
1391| 10.2k| else
1392| 10.2k| ret_val = EOB_ACT_CONTINUE_SCAN;
------------------
| | 409| 10.2k|#define EOB_ACT_CONTINUE_SCAN 0
------------------
1393| |
1394| 16.2k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
| Branch (1394:6): [True: 0, False: 16.2k]
------------------
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.2k| yyg->yy_n_chars += number_to_move;
1406| 16.2k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 16.2k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1407| 16.2k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
------------------
| | 380| 16.2k|#define YY_END_OF_BUFFER_CHAR 0
------------------
1408| |
1409| 16.2k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 579| 16.2k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
------------------
| | 527| 16.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1410| |
1411| 16.2k| return ret_val;
1412| 16.2k|}
ncol-lexer.c:yy_get_previous_state:
1417| 12.7k|{
1418| 12.7k| yy_state_type yy_current_state;
1419| 12.7k| char *yy_cp;
1420| 12.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1421| |
1422| 12.7k| yy_current_state = yyg->yy_start;
1423| |
1424| 245M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
------------------
| | 579| 12.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| 12.7k|#define YY_MORE_ADJ 0
------------------
| Branch (1424:47): [True: 245M, False: 12.7k]
------------------
1425| 245M| {
1426| 245M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
------------------
| | 346| 245M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
------------------
| Branch (1426:19): [True: 245M, False: 0]
------------------
1427| 245M| if ( yy_accept[yy_current_state] )
------------------
| Branch (1427:8): [True: 245M, False: 10.2k]
------------------
1428| 245M| {
1429| 245M| yyg->yy_last_accepting_state = yy_current_state;
1430| 245M| yyg->yy_last_accepting_cpos = yy_cp;
1431| 245M| }
1432| 491M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
------------------
| Branch (1432:11): [True: 245M, False: 245M]
------------------
1433| 245M| {
1434| 245M| yy_current_state = (int) yy_def[yy_current_state];
1435| 245M| if ( yy_current_state >= 15 )
------------------
| Branch (1435:9): [True: 245M, False: 6.40k]
------------------
1436| 245M| yy_c = yy_meta[yy_c];
1437| 245M| }
1438| 245M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1439| 245M| }
1440| |
1441| 12.7k| return yy_current_state;
1442| 12.7k|}
ncol-lexer.c:igraph_ncol_yy_load_buffer_state:
1616| 10.4k|{
1617| 10.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1618| 10.4k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
------------------
| | 527| 10.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1619| 10.4k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 579| 10.4k|#define yytext_ptr yytext_r
------------------
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
------------------
| | 527| 10.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1620| 10.4k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 356| 10.4k|#define yyin yyg->yyin_r
------------------
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
------------------
| | 527| 10.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
------------------
1621| 10.4k| yyg->yy_hold_char = *yyg->yy_c_buf_p;
1622| 10.4k|}
ncol-lexer.c:igraph_ncol_yy_init_buffer:
1680| 6.95k|{
1681| 6.95k| int oerrno = errno;
1682| 6.95k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1683| |
1684| 6.95k| yy_flush_buffer( b , yyscanner);
------------------
| | 56| 6.95k|#define yy_flush_buffer igraph_ncol_yy_flush_buffer
------------------
1685| |
1686| 6.95k| b->yy_input_file = file;
1687| 6.95k| 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.95k| if (b != YY_CURRENT_BUFFER){
------------------
| | 521| 6.95k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
| | ------------------
| | | Branch (521:29): [True: 6.95k, False: 0]
| | ------------------
| | 522| 6.95k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
| | 523| 6.95k| : NULL)
------------------
| Branch (1693:9): [True: 3.47k, False: 3.47k]
------------------
1694| 3.47k| b->yy_bs_lineno = 1;
1695| 3.47k| b->yy_bs_column = 0;
1696| 3.47k| }
1697| |
1698| 6.95k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
------------------
| Branch (1698:32): [True: 6.95k, False: 0]
------------------
1699| |
1700| | errno = oerrno;
1701| 6.95k|}
ncol-lexer.c:igraph_ncol_yyensure_buffer_stack:
1789| 3.47k|{
1790| 3.47k| yy_size_t num_to_alloc;
1791| 3.47k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1792| |
1793| 3.47k| if (!yyg->yy_buffer_stack) {
------------------
| Branch (1793:6): [True: 3.47k, 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.47k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1800| 3.47k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
------------------
| | 236| 3.47k|#define yyalloc igraph_ncol_yyalloc
------------------
1801| 3.47k| (num_to_alloc * sizeof(struct yy_buffer_state*)
1802| 3.47k| , yyscanner);
1803| 3.47k| if ( ! yyg->yy_buffer_stack )
------------------
| Branch (1803:8): [True: 0, False: 3.47k]
------------------
1804| 3.47k| 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.47k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1807| |
1808| 3.47k| yyg->yy_buffer_stack_max = num_to_alloc;
1809| 3.47k| yyg->yy_buffer_stack_top = 0;
1810| 3.47k| return;
1811| 3.47k| }
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.95k|{
2179| 6.95k| 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.95k| yyg->yy_buffer_stack = NULL;
2185| 6.95k| yyg->yy_buffer_stack_top = 0;
2186| 6.95k| yyg->yy_buffer_stack_max = 0;
2187| 6.95k| yyg->yy_c_buf_p = NULL;
2188| 6.95k| yyg->yy_init = 0;
2189| 6.95k| yyg->yy_start = 0;
2190| |
2191| 6.95k| yyg->yy_start_stack_ptr = 0;
2192| 6.95k| yyg->yy_start_stack_depth = 0;
2193| 6.95k| 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.95k| yyin = NULL;
------------------
| | 356| 6.95k|#define yyin yyg->yyin_r
------------------
2201| 6.95k| yyout = NULL;
------------------
| | 357| 6.95k|#define yyout yyg->yyout_r
------------------
2202| 6.95k|#endif
2203| |
2204| | /* For future reference: Set errno on error, since we are called by
2205| | * yylex_init()
2206| | */
2207| 6.95k| return 0;
2208| 6.95k|}
igraph_ncol_yyparse:
1184| 3.47k|{
1185| |/* The lookahead symbol. */
1186| 3.47k|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.47k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
------------------
| | 358| 3.47k|# define YY_INITIAL_VALUE(Value) Value
------------------
1193| 3.47k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
------------------
| | 358| 3.47k|# define YY_INITIAL_VALUE(Value) Value
------------------
1194| |
1195| |/* Location data for the lookahead symbol. */
1196| 3.47k|static YYLTYPE yyloc_default
1197| 3.47k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1198| 3.47k| = { 1, 1, 1, 1 }
1199| 3.47k|# endif
1200| 3.47k|;
1201| 3.47k|YYLTYPE yylloc = yyloc_default;
1202| |
1203| | /* Number of syntax errors so far. */
1204| 3.47k| int yynerrs;
1205| |
1206| 3.47k| yy_state_fast_t yystate;
1207| | /* Number of tokens to shift before error messages enabled. */
1208| 3.47k| 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.47k| yy_state_t yyssa[YYINITDEPTH];
1220| 3.47k| yy_state_t *yyss;
1221| 3.47k| yy_state_t *yyssp;
1222| |
1223| | /* The semantic value stack. */
1224| 3.47k| YYSTYPE yyvsa[YYINITDEPTH];
1225| 3.47k| YYSTYPE *yyvs;
1226| 3.47k| YYSTYPE *yyvsp;
1227| |
1228| | /* The location stack. */
1229| 3.47k| YYLTYPE yylsa[YYINITDEPTH];
1230| 3.47k| YYLTYPE *yyls;
1231| 3.47k| YYLTYPE *yylsp;
1232| |
1233| | /* The locations where the error started and ended. */
1234| 3.47k| YYLTYPE yyerror_range[3];
1235| |
1236| 3.47k| YYPTRDIFF_T yystacksize;
------------------
| | 273| 3.47k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1237| |
1238| 3.47k| int yyn;
1239| 3.47k| int yyresult;
1240| | /* Lookahead token as an internal (translated) token number. */
1241| 3.47k| int yytoken = 0;
1242| | /* The variables used to return semantic value and location from the
1243| | action routines. */
1244| 3.47k| YYSTYPE yyval;
1245| 3.47k| YYLTYPE yyloc;
1246| |
1247| 3.47k|#if YYERROR_VERBOSE
1248| | /* Buffer for error messages, and its allocated size. */
1249| 3.47k| char yymsgbuf[128];
1250| 3.47k| char *yymsg = yymsgbuf;
1251| 3.47k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
------------------
| | 273| 3.47k|# define YYPTRDIFF_T __PTRDIFF_TYPE__
------------------
1252| 3.47k|#endif
1253| |
1254| 3.47k|#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.47k| int yylen = 0;
1259| |
1260| 3.47k| yyssp = yyss = yyssa;
1261| 3.47k| yyvsp = yyvs = yyvsa;
1262| 3.47k| yylsp = yyls = yylsa;
1263| 3.47k| yystacksize = YYINITDEPTH;
------------------
| | 909| 3.47k|# define YYINITDEPTH 200
------------------
1264| |
1265| 3.47k| YYDPRINTF ((stderr, "Starting parse\n"));
1266| |
1267| 3.47k| yystate = 0;
1268| 3.47k| yyerrstatus = 0;
1269| 3.47k| yynerrs = 0;
------------------
| | 71| 3.47k|#define yynerrs igraph_ncol_yynerrs
------------------
1270| 3.47k| yychar = YYEMPTY; /* Cause a token to be read. */
------------------
| | 673| 3.47k|#define YYEMPTY (-2)
------------------
1271| 3.47k| yylsp[0] = yylloc;
1272| 3.47k| goto yysetstate;
1273| |
1274| |
1275| |/*------------------------------------------------------------.
1276| || yynewstate -- push a new state, which is found in yystate. |
1277| |`------------------------------------------------------------*/
1278| 2.40M|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.40M| yyssp++;
1282| |
1283| |
1284| |/*--------------------------------------------------------------------.
1285| || yysetstate -- set current state (the top of the stack) to yystate. |
1286| |`--------------------------------------------------------------------*/
1287| 2.40M|yysetstate:
1288| 2.40M| YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1289| 2.40M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
------------------
| | 381| 2.40M|#define YY_ASSERT(E) ((void) (0 && (E)))
| | ------------------
| | | Branch (381:31): [Folded, False: 2.40M]
| | | Branch (381:37): [True: 0, False: 0]
| | | Branch (381:37): [True: 0, False: 0]
| | ------------------
------------------
1290| 2.40M| YY_IGNORE_USELESS_CAST_BEGIN
1291| 2.40M| *yyssp = YY_CAST (yy_state_t, yystate);
------------------
| | 125| 2.40M|# define YY_CAST(Type, Val) ((Type) (Val))
------------------
1292| 2.40M| YY_IGNORE_USELESS_CAST_END
1293| |
1294| 2.40M| if (yyss + yystacksize - 1 <= yyssp)
------------------
| Branch (1294:7): [True: 0, False: 2.40M]
------------------
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.40M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1361| |
1362| 2.40M| if (yystate == YYFINAL)
------------------
| | 515| 2.40M|#define YYFINAL 2
------------------
| Branch (1362:7): [True: 3.47k, False: 2.40M]
------------------
1363| 3.47k| YYACCEPT;
------------------
| | 676| 3.47k|#define YYACCEPT goto yyacceptlab
------------------
1364| |
1365| 2.40M| goto yybackup;
1366| |
1367| |
1368| |/*-----------.
1369| || yybackup. |
1370| |`-----------*/
1371| 2.40M|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.40M| yyn = yypact[yystate];
1377| 2.40M| if (yypact_value_is_default (yyn))
------------------
| | 601| 2.40M| ((Yyn) == YYPACT_NINF)
| | ------------------
| | | | 598| 2.40M|#define YYPACT_NINF (-3)
| | ------------------
| | | Branch (601:3): [True: 1.48M, False: 923k]
| | ------------------
------------------
1378| 1.48M| 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| 923k| if (yychar == YYEMPTY)
------------------
| | 673| 923k|#define YYEMPTY (-2)
------------------
| Branch (1383:7): [True: 923k, False: 0]
------------------
1384| 923k| {
1385| 923k| YYDPRINTF ((stderr, "Reading a token: "));
1386| 923k| yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 68| 923k|#define yylex igraph_ncol_yylex
------------------
yychar = yylex (&yylval, &yylloc, scanner);
------------------
| | 116| 923k|#define scanner context->scanner
------------------
1387| 923k| }
1388| |
1389| 923k| if (yychar <= YYEOF)
------------------
| | 674| 923k|#define YYEOF 0
------------------
| Branch (1389:7): [True: 3.47k, False: 919k]
------------------
1390| 3.47k| {
1391| 3.47k| yychar = yytoken = YYEOF;
------------------
| | 674| 3.47k|#define YYEOF 0
------------------
1392| 3.47k| YYDPRINTF ((stderr, "Now at end of input.\n"));
1393| 3.47k| }
1394| 919k| else
1395| 919k| {
1396| 919k| yytoken = YYTRANSLATE (yychar);
------------------
| | 535| 919k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 529| 919k|#define YYMAXUTOK 260
| | ------------------
| | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
| | ------------------
| | | | 528| 0|#define YYUNDEFTOK 2
| | ------------------
| | | Branch (535:4): [True: 919k, False: 0]
| | | Branch (535:18): [True: 919k, False: 0]
| | ------------------
------------------
1397| 919k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1398| 919k| }
1399| |
1400| | /* If the proper action on seeing token YYTOKEN is to reduce or to
1401| | detect an error, take that action. */
1402| 923k| yyn += yytoken;
1403| 923k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
------------------
| | 517| 923k|#define YYLAST 7
------------------
| Branch (1403:7): [True: 0, False: 923k]
| Branch (1403:18): [True: 0, False: 923k]
| Branch (1403:34): [True: 0, False: 923k]
------------------
1404| 0| goto yydefault;
1405| 923k| yyn = yytable[yyn];
1406| 923k| if (yyn <= 0)
------------------
| Branch (1406:7): [True: 0, False: 923k]
------------------
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| 923k| if (yyerrstatus)
------------------
| Branch (1416:7): [True: 0, False: 923k]
------------------
1417| 0| yyerrstatus--;
1418| |
1419| | /* Shift the lookahead token. */
1420| 923k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1421| 923k| yystate = yyn;
1422| 923k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1423| 923k| *++yyvsp = yylval;
1424| 923k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1425| 923k| *++yylsp = yylloc;
1426| |
1427| | /* Discard the shifted token. */
1428| 923k| yychar = YYEMPTY;
------------------
| | 673| 923k|#define YYEMPTY (-2)
------------------
1429| 923k| goto yynewstate;
1430| |
1431| |
1432| |/*-----------------------------------------------------------.
1433| || yydefault -- do the default action for the current state. |
1434| |`-----------------------------------------------------------*/
1435| 1.48M|yydefault:
1436| 1.48M| yyn = yydefact[yystate];
1437| 1.48M| if (yyn == 0)
------------------
| Branch (1437:7): [True: 0, False: 1.48M]
------------------
1438| 0| goto yyerrlab;
1439| 1.48M| goto yyreduce;
1440| |
1441| |
1442| |/*-----------------------------.
1443| || yyreduce -- do a reduction. |
1444| |`-----------------------------*/
1445| 1.48M|yyreduce:
1446| | /* yyn is the number of a rule to reduce with. */
1447| 1.48M| 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.48M| yyval = yyvsp[1-yylen];
1458| |
1459| | /* Default location. */
1460| 1.48M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
------------------
| | 711| 1.48M| do \
| | 712| 1.48M| if (N) \
| | ------------------
| | | Branch (712:11): [True: 1.47M, False: 3.47k]
| | ------------------
| | 713| 1.48M| { \
| | 714| 1.47M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
| | ------------------
| | | | 729| 1.47M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 715| 1.47M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
| | ------------------
| | | | 729| 1.47M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 716| 1.47M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
| | ------------------
| | | | 729| 1.47M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 717| 1.47M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
| | ------------------
| | | | 729| 1.47M|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 718| 1.47M| } \
| | 719| 1.48M| else \
| | 720| 1.48M| { \
| | 721| 3.47k| (Current).first_line = (Current).last_line = \
| | 722| 3.47k| YYRHSLOC (Rhs, 0).last_line; \
| | ------------------
| | | | 729| 3.47k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 723| 3.47k| (Current).first_column = (Current).last_column = \
| | 724| 3.47k| YYRHSLOC (Rhs, 0).last_column; \
| | ------------------
| | | | 729| 3.47k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
| | ------------------
| | 725| 3.47k| } \
| | 726| 1.48M| while (0)
| | ------------------
| | | Branch (726:12): [Folded, False: 1.48M]
| | ------------------
------------------
1461| 1.48M| yyerror_range[1] = yyloc;
1462| 1.48M| YY_REDUCE_PRINT (yyn);
1463| 1.48M| switch (yyn)
1464| 1.48M| {
1465| 196k| case 5:
------------------
| Branch (1465:3): [True: 196k, False: 1.28M]
------------------
1466| 196k|#line 97 "/src/igraph/src/io/ncol-parser.y"
1467| 196k| {
1468| 196k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, 1.0));
------------------
| | 10| 196k| do { \
| | 11| 196k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 196k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 196k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 196k]
| | | | ------------------
| | ------------------
| | 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| 196k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 196k]
| | ------------------
------------------
1469| 196k| }
1470| 196k|#line 1471 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1471| 196k| break;
1472| |
1473| 196k| case 6:
------------------
| Branch (1473:3): [True: 82.2k, False: 1.39M]
------------------
1474| 82.2k|#line 100 "/src/igraph/src/io/ncol-parser.y"
1475| 82.2k| {
1476| 82.2k| IGRAPH_YY_CHECK(igraph_vector_push_back(context->weights, (yyvsp[-1].weightnum)));
------------------
| | 10| 82.2k| do { \
| | 11| 82.2k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 82.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 82.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.2k]
| | | | ------------------
| | ------------------
| | 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| 82.2k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 82.2k]
| | ------------------
------------------
1477| 82.2k| context->has_weights = true;
1478| 82.2k| }
1479| 0|#line 1480 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1480| 0| break;
1481| |
1482| 279k| case 7:
------------------
| Branch (1482:3): [True: 279k, False: 1.20M]
------------------
1483| 279k|#line 106 "/src/igraph/src/io/ncol-parser.y"
1484| 279k| {
1485| 279k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[-1].edgenum)));
------------------
| | 10| 279k| do { \
| | 11| 279k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 279k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 279k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 279k]
| | | | ------------------
| | ------------------
| | 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| 279k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 279k]
| | ------------------
------------------
1486| 279k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(context->vector, (yyvsp[0].edgenum)));
------------------
| | 10| 279k| do { \
| | 11| 279k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 279k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 279k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 279k]
| | | | ------------------
| | ------------------
| | 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| 279k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 279k]
| | ------------------
------------------
1487| 279k|}
1488| 279k|#line 1489 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1489| 279k| break;
1490| |
1491| 558k| case 8:
------------------
| Branch (1491:3): [True: 558k, False: 923k]
------------------
1492| 558k|#line 111 "/src/igraph/src/io/ncol-parser.y"
1493| 558k| {
1494| 558k| igraph_int_t trie_id;
1495| 558k| IGRAPH_YY_CHECK(igraph_trie_get_len(context->trie,
------------------
| | 10| 558k| do { \
| | 11| 558k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 558k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 558k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 558k]
| | | | ------------------
| | ------------------
| | 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| 558k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 558k]
| | ------------------
------------------
1496| 558k| igraph_ncol_yyget_text(scanner),
1497| 558k| igraph_ncol_yyget_leng(scanner),
1498| 558k| &trie_id
1499| 558k| ));
1500| 558k| (yyval.edgenum) = trie_id;
1501| 558k|}
1502| 0|#line 1503 "/src/igraph/build/src/io/parsers/ncol-parser.c"
1503| 0| break;
1504| |
1505| 82.2k| case 9:
------------------
| Branch (1505:3): [True: 82.2k, False: 1.39M]
------------------
1506| 82.2k|#line 121 "/src/igraph/src/io/ncol-parser.y"
1507| 82.2k| {
1508| 82.2k| igraph_real_t val;
1509| 82.2k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_ncol_yyget_text(scanner),
------------------
| | 10| 82.2k| do { \
| | 11| 82.2k| igraph_error_t igraph_i_ret = (expr); \
| | 12| 82.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \
| | ------------------
| | | | 612| 82.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.2k]
| | | | ------------------
| | ------------------
| | 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| 82.2k| } while (0)
| | ------------------
| | | Branch (17:14): [Folded, False: 82.2k]
| | ------------------
------------------
1510| 82.2k| igraph_ncol_yyget_leng(scanner),
1511| 82.2k| &val));
1512| 82.2k| (yyval.weightnum)=val;
1513| 82.2k|}
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| 282k| default: break;
------------------
| Branch (1520:7): [True: 282k, False: 1.19M]
------------------
1521| 1.48M| }
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.48M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1534| |
1535| 1.48M| YYPOPSTACK (yylen);
------------------
| | 1254| 1.48M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1536| 1.48M| yylen = 0;
1537| 1.48M| YY_STACK_PRINT (yyss, yyssp);
1538| |
1539| 1.48M| *++yyvsp = yyval;
1540| 1.48M| *++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.48M| {
1546| 1.48M| const int yylhs = yyr1[yyn] - YYNTOKENS;
------------------
| | 520| 1.48M|#define YYNTOKENS 6
------------------
1547| 1.48M| const int yyi = yypgoto[yylhs] + *yyssp;
1548| 1.48M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
------------------
| | 517| 2.12M|#define YYLAST 7
------------------
| Branch (1548:16): [True: 640k, False: 841k]
| Branch (1548:28): [True: 640k, False: 0]
| Branch (1548:45): [True: 279k, False: 361k]
------------------
1549| 1.48M| ? yytable[yyi]
1550| 1.48M| : yydefgoto[yylhs]);
1551| 1.48M| }
1552| |
1553| 1.48M| 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.47k|yyacceptlab:
1701| 3.47k| yyresult = 0;
1702| 3.47k| 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.47k|yyreturn:
1728| 3.47k| if (yychar != YYEMPTY)
------------------
| | 673| 3.47k|#define YYEMPTY (-2)
------------------
| Branch (1728:7): [True: 0, False: 3.47k]
------------------
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.47k| YYPOPSTACK (yylen);
------------------
| | 1254| 3.47k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1739| 3.47k| YY_STACK_PRINT (yyss, yyssp);
1740| 10.4k| while (yyssp != yyss)
------------------
| Branch (1740:10): [True: 6.95k, False: 3.47k]
------------------
1741| 6.95k| {
1742| 6.95k| yydestruct ("Cleanup: popping",
1743| 6.95k| yystos[+*yyssp], yyvsp, yylsp, context);
1744| 6.95k| YYPOPSTACK (1);
------------------
| | 1254| 6.95k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
------------------
1745| 6.95k| }
1746| 3.47k|#ifndef yyoverflow
1747| 3.47k| if (yyss != yyssa)
------------------
| Branch (1747:7): [True: 0, False: 3.47k]
------------------
1748| 0| YYSTACK_FREE (yyss);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1749| 3.47k|#endif
1750| 3.47k|#if YYERROR_VERBOSE
1751| 3.47k| if (yymsg != yymsgbuf)
------------------
| Branch (1751:7): [True: 0, False: 3.47k]
------------------
1752| 0| YYSTACK_FREE (yymsg);
------------------
| | 423| 0|# define YYSTACK_FREE YYFREE
| | ------------------
| | | | 442| 0|# define YYFREE free
| | ------------------
------------------
1753| 3.47k|#endif
1754| 3.47k| return yyresult;
1755| 0|}
ncol-parser.c:yydestruct:
1162| 6.95k|{
1163| 6.95k| YYUSE (yyvaluep);
------------------
| | 344| 6.95k|# define YYUSE(E) ((void) (E))
------------------
1164| 6.95k| YYUSE (yylocationp);
------------------
| | 344| 6.95k|# define YYUSE(E) ((void) (E))
------------------
1165| 6.95k| YYUSE (context);
------------------
| | 344| 6.95k|# define YYUSE(E) ((void) (E))
------------------
1166| 6.95k| if (!yymsg)
------------------
| Branch (1166:7): [True: 0, False: 6.95k]
------------------
1167| 0| yymsg = "Deleting";
1168| 6.95k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1169| |
1170| 6.95k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1171| 6.95k| YYUSE (yytype);
------------------
| | 344| 6.95k|# define YYUSE(E) ((void) (E))
------------------
1172| 6.95k| YY_IGNORE_MAYBE_UNINITIALIZED_END
1173| 6.95k|}
LLVMFuzzerTestOneInput:
36| 21.3k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
37| |
38| 21.3k| igraph_set_error_handler(igraph_error_handler_ignore);
39| 21.3k| igraph_set_warning_handler(igraph_warning_handler_ignore);
40| |
41| | // Turn on attribute handling
42| 21.3k| igraph_set_attribute_table(&igraph_cattribute_table);
43| |
44| | // Read input file
45| 21.3k| FILE *ifile = fmemopen((void*) data, size, "r");
46| 21.3k| if (!ifile) {
------------------
| Branch (46:9): [True: 0, False: 21.3k]
------------------
47| 0| return 0;
48| 0| }
49| |
50| | // Do the fuzzing
51| 21.3k| igraph_t g;
52| 21.3k| if (igraph_read_graph_graphml(&g, ifile, 0) == IGRAPH_SUCCESS) {
------------------
| Branch (52:9): [True: 3.57k, False: 17.7k]
------------------
53| 3.57k| FILE *file;
54| 3.57k| igraph_t g2;
55| |
56| 3.57k| file = tmpfile();
57| 3.57k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.57k| do { \
| | 925| 3.57k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.57k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.57k]
| | ------------------
------------------
58| | // Do not check error because:
59| | // "Vertex attribute values cannot contain newline characters."
60| 3.57k| igraph_write_graph_leda(&g, file, "label", "weight");
61| 3.57k| fclose(file);
62| |
63| 3.57k| file = tmpfile();
64| 3.57k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.57k| do { \
| | 925| 3.57k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.57k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.57k]
| | ------------------
------------------
65| 3.57k| CHECK_ERR(igraph_write_graph_dot(&g, file));
------------------
| | 29| 3.57k| do { \
| | 30| 3.57k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.57k| expr; \
| | 32| 3.57k| igraph_set_error_handler(handler); \
| | 33| 3.57k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.57k]
| | ------------------
------------------
66| 3.57k| fclose(file);
67| |
68| 3.57k| file = tmpfile();
69| 3.57k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.57k| do { \
| | 925| 3.57k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.57k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.57k]
| | ------------------
------------------
70| 3.57k| CHECK_ERR(igraph_write_graph_gml(&g, file, IGRAPH_WRITE_GML_DEFAULT_SW, NULL, "no one"));
------------------
| | 29| 3.57k| do { \
| | 30| 3.57k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.57k| expr; \
| | 32| 3.57k| igraph_set_error_handler(handler); \
| | 33| 3.57k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.57k]
| | ------------------
------------------
71| 3.57k| rewind(file);
72| 3.57k| CHECK_ERR(igraph_read_graph_gml(&g2, file));
------------------
| | 29| 3.57k| do { \
| | 30| 3.57k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.57k| expr; \
| | 32| 3.57k| igraph_set_error_handler(handler); \
| | 33| 3.57k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.57k]
| | ------------------
------------------
73| 3.57k| igraph_destroy(&g2);
74| 3.57k| fclose(file);
75| |
76| | // Reading Pajek files back is disabled because of
77| | // https://github.com/igraph/igraph/issues/2560
78| 3.57k| file = tmpfile();
79| 3.57k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.57k| do { \
| | 925| 3.57k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.57k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.57k]
| | ------------------
------------------
80| 3.57k| CHECK_ERR(igraph_write_graph_pajek(&g, file));
------------------
| | 29| 3.57k| do { \
| | 30| 3.57k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.57k| expr; \
| | 32| 3.57k| igraph_set_error_handler(handler); \
| | 33| 3.57k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.57k]
| | ------------------
------------------
81| | /*
82| | rewind(file);
83| | CHECK_ERR(igraph_read_graph_pajek(&g2, file));
84| | igraph_destroy(&g2);
85| | */
86| 3.57k| fclose(file);
87| |
88| 3.57k| file = tmpfile();
89| 3.57k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.57k| do { \
| | 925| 3.57k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.57k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.57k]
| | ------------------
------------------
90| | // Do not check error when writing GraphML because string attributes
91| | // may contain forbidden control characters.
92| 3.57k| if (igraph_write_graph_graphml(&g, file, false) == IGRAPH_SUCCESS) {
------------------
| Branch (92:13): [True: 3.57k, False: 0]
------------------
93| 3.57k| rewind(file);
94| | // Do not check error when reading because strings may not be
95| | // in a valid encoding, which confuses libxml2.
96| 3.57k| if (igraph_read_graph_graphml(&g2, file, 0) == IGRAPH_SUCCESS) {
------------------
| Branch (96:17): [True: 3.53k, False: 40]
------------------
97| 3.53k| igraph_destroy(&g2);
98| 3.53k| }
99| 3.57k| }
100| 3.57k| fclose(file);
101| |
102| 3.57k| file = tmpfile();
103| 3.57k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.57k| do { \
| | 925| 3.57k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.57k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.57k]
| | ------------------
------------------
104| | // Do not check error when writing LGL because not all possible
105| | // vertex names are supported by this format.
106| 3.57k| if (igraph_write_graph_lgl(&g, file, "label", "weight", false) == IGRAPH_SUCCESS) {
------------------
| Branch (106:13): [True: 3.42k, False: 152]
------------------
107| 3.42k| rewind(file);
108| 3.42k| CHECK_ERR(igraph_read_graph_lgl(&g2, file, true, IGRAPH_ADD_WEIGHTS_IF_PRESENT, true));
------------------
| | 29| 3.42k| do { \
| | 30| 3.42k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.42k| expr; \
| | 32| 3.42k| igraph_set_error_handler(handler); \
| | 33| 3.42k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.42k]
| | ------------------
------------------
109| 3.42k| igraph_destroy(&g2);
110| 3.42k| }
111| 3.57k| fclose(file);
112| |
113| 3.57k| file = tmpfile();
114| 3.57k| IGRAPH_ASSERT(file != NULL);
------------------
| | 924| 3.57k| do { \
| | 925| 3.57k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 3.57k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.57k]
| | ------------------
------------------
115| | // Do not check error when writing NCOL because not all possible
116| | // vertex names are supported by this format.
117| 3.57k| if (igraph_write_graph_ncol(&g, file, "label", "weight") == IGRAPH_SUCCESS) {
------------------
| Branch (117:13): [True: 3.47k, False: 100]
------------------
118| 3.47k| rewind(file);
119| 3.47k| CHECK_ERR(igraph_read_graph_ncol(&g2, file, NULL, true, IGRAPH_ADD_WEIGHTS_IF_PRESENT, true));
------------------
| | 29| 3.47k| do { \
| | 30| 3.47k| igraph_error_handler_t *handler = igraph_set_error_handler(igraph_error_handler_abort); \
| | 31| 3.47k| expr; \
| | 32| 3.47k| igraph_set_error_handler(handler); \
| | 33| 3.47k| } while (0)
| | ------------------
| | | Branch (33:14): [Folded, False: 3.47k]
| | ------------------
------------------
120| 3.47k| igraph_destroy(&g2);
121| 3.47k| }
122| 3.57k| fclose(file);
123| |
124| | // Clean up
125| 3.57k| igraph_destroy(&g);
126| 3.57k| }
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| 21.3k| fclose(ifile);
132| |
133| 21.3k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY);
------------------
| | 924| 21.3k| do { \
| | 925| 21.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 21.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 21.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | ------------------
| | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__
| | ------------------
| | 927| 0| } \
| | 928| 21.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 21.3k]
| | ------------------
------------------
134| |
135| 21.3k| return 0;
136| 21.3k|}
igraph_error:
210| 19.7k| igraph_error_t igraph_errno) {
211| |
212| 19.7k| if (igraph_i_error_handler) {
------------------
| Branch (212:9): [True: 19.7k, False: 0]
------------------
213| 19.7k| igraph_i_error_handler(reason, file, line, igraph_errno);
214| 19.7k|#ifndef USING_R
215| 19.7k| } else {
216| 0| igraph_error_handler_abort(reason, file, line, igraph_errno);
217| 0|#endif
218| 0| }
219| 19.7k| return igraph_errno;
220| 19.7k|}
igraph_errorf:
240| 629| igraph_error_t igraph_errno, ...) {
241| 629| va_list ap;
242| 629| va_start(ap, igraph_errno);
243| 629| vsnprintf(igraph_i_errormsg_buffer,
244| 629| sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap);
245| | va_end(ap);
246| 629| return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno);
247| 629|}
igraph_error_handler_ignore:
266| 19.7k| int line, igraph_error_t igraph_errno) {
267| 19.7k| IGRAPH_UNUSED(reason);
------------------
| | 30| 19.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
268| 19.7k| IGRAPH_UNUSED(file);
------------------
| | 30| 19.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
269| 19.7k| IGRAPH_UNUSED(line);
------------------
| | 30| 19.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
270| 19.7k| IGRAPH_UNUSED(igraph_errno);
------------------
| | 30| 19.7k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
271| |
272| 19.7k| IGRAPH_FINALLY_FREE();
273| 19.7k|}
igraph_set_error_handler:
298| 63.7k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) {
299| 63.7k| igraph_error_handler_t *previous_handler = igraph_i_error_handler;
300| 63.7k| igraph_i_error_handler = new_handler;
301| 63.7k| return previous_handler;
302| 63.7k|}
IGRAPH_FINALLY_REAL:
320| 12.4M|void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) {
321| 12.4M| int no = igraph_i_finally_stack_size;
322| 12.4M| if (no < 0) {
------------------
| Branch (322:9): [True: 0, False: 12.4M]
------------------
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| 12.4M| if (no >= (int) (sizeof(igraph_i_finally_stack) / sizeof(igraph_i_finally_stack[0]))) {
------------------
| Branch (327:9): [True: 0, False: 12.4M]
------------------
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| 12.4M| igraph_i_finally_stack[no].ptr = ptr;
333| 12.4M| igraph_i_finally_stack[no].func = func;
334| 12.4M| igraph_i_finally_stack[no].level = igraph_i_finally_stack_level;
335| 12.4M| igraph_i_finally_stack_size++;
336| 12.4M|}
IGRAPH_FINALLY_CLEAN:
338| 7.53M|void IGRAPH_FINALLY_CLEAN(int minus) {
339| 7.53M| igraph_i_finally_stack_size -= minus;
340| 7.53M| if (igraph_i_finally_stack_size < 0) {
------------------
| Branch (340:9): [True: 0, False: 7.53M]
------------------
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| 7.53M|}
IGRAPH_FINALLY_FREE:
348| 19.7k|void IGRAPH_FINALLY_FREE(void) {
349| 57.2k| for (; igraph_i_finally_stack_size > 0; igraph_i_finally_stack_size--) {
------------------
| Branch (349:12): [True: 38.9k, False: 18.3k]
------------------
350| 38.9k| int p = igraph_i_finally_stack_size - 1;
351| | /* Call destructors only up to the current level */
352| 38.9k| if (igraph_i_finally_stack[p].level < igraph_i_finally_stack_level) {
------------------
| Branch (352:13): [True: 1.37k, False: 37.5k]
------------------
353| 1.37k| break;
354| 1.37k| }
355| 37.5k| igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr);
356| 37.5k| }
357| 19.7k|}
IGRAPH_FINALLY_STACK_SIZE:
359| 21.3k|int IGRAPH_FINALLY_STACK_SIZE(void) {
360| 21.3k| return igraph_i_finally_stack_size;
361| 21.3k|}
IGRAPH_FINALLY_ENTER:
377| 2.11M|void IGRAPH_FINALLY_ENTER(void) {
378| 2.11M| int no = igraph_i_finally_stack_size;
379| | /* Level indices must always be in increasing order in the finally stack */
380| 2.11M| if (no > 0 && igraph_i_finally_stack[no-1].level > igraph_i_finally_stack_level) {
------------------
| Branch (380:9): [True: 2.11M, False: 0]
| Branch (380:19): [True: 0, False: 2.11M]
------------------
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.11M| igraph_i_finally_stack_level++;
386| 2.11M|}
IGRAPH_FINALLY_EXIT:
399| 2.11M|void IGRAPH_FINALLY_EXIT(void) {
400| 2.11M| igraph_i_finally_stack_level--;
401| 2.11M| if (igraph_i_finally_stack_level < 0) {
------------------
| Branch (401:9): [True: 0, False: 2.11M]
------------------
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.11M|}
igraph_warning_handler_ignore:
424| 54.1k|void igraph_warning_handler_ignore(const char *reason, const char *file, int line) {
425| 54.1k| IGRAPH_UNUSED(reason);
------------------
| | 30| 54.1k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
426| 54.1k| IGRAPH_UNUSED(file);
------------------
| | 30| 54.1k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
427| 54.1k| IGRAPH_UNUSED(line);
------------------
| | 30| 54.1k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
428| 54.1k|}
igraph_warning:
463| 54.1k|void igraph_warning(const char *reason, const char *file, int line) {
464| |
465| 54.1k| if (igraph_i_warning_handler) {
------------------
| Branch (465:9): [True: 54.1k, False: 0]
------------------
466| 54.1k| igraph_i_warning_handler(reason, file, line);
467| 54.1k|#ifndef USING_R
468| 54.1k| } else {
469| 0| igraph_warning_handler_print(reason, file, line);
470| 0|#endif
471| 0| }
472| 54.1k|}
igraph_warningf:
492| 39.4k|void igraph_warningf(const char *reason, const char *file, int line, ...) {
493| 39.4k| va_list ap;
494| 39.4k| va_start(ap, line);
495| 39.4k| vsnprintf(igraph_i_warningmsg_buffer,
496| 39.4k| sizeof(igraph_i_warningmsg_buffer) / sizeof(char), reason, ap);
497| | va_end(ap);
498| 39.4k| igraph_warning(igraph_i_warningmsg_buffer, file, line);
499| 39.4k|}
igraph_set_warning_handler:
514| 21.3k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) {
515| 21.3k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler;
516| 21.3k| igraph_i_warning_handler = new_handler;
517| 21.3k| return previous_handler;
518| 21.3k|}
igraph_free:
62| 193k|void igraph_free(void *ptr) {
63| | IGRAPH_FREE(ptr);
------------------
| | 36| 193k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
64| 193k|}
igraph_real_fprintf_precise:
117| 338k|int igraph_real_fprintf_precise(FILE *file, igraph_real_t val) {
118| 338k| if (isfinite(val)) {
------------------
| Branch (118:9): [True: 8.98k, False: 329k]
------------------
119| 8.98k| return fprintf(file, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
------------------
| | 54| 8.98k| #define IGRAPH_REAL_PRINTF_PRECISE_FORMAT "%." IGRAPH_I_STRINGIFY(DBL_DIG) "g"
------------------
120| 329k| } else if (isnan(val)) {
------------------
| Branch (120:16): [True: 329k, False: 0]
------------------
121| 329k| return fprintf(file, "NaN");
122| 329k| } 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| 86.9k|int igraph_real_snprintf_precise(char *str, size_t size, igraph_real_t val) {
139| 86.9k| if (isfinite(val)) {
------------------
| Branch (139:9): [True: 1.45k, False: 85.4k]
------------------
140| 1.45k| return snprintf(str, size, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
------------------
| | 54| 1.45k| #define IGRAPH_REAL_PRINTF_PRECISE_FORMAT "%." IGRAPH_I_STRINGIFY(DBL_DIG) "g"
------------------
141| 85.4k| } else if (isnan(val)) {
------------------
| Branch (141:16): [True: 85.4k, False: 0]
------------------
142| 85.4k| return snprintf(str, size, "NaN");
143| 85.4k| } 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| 298k|igraph_error_t igraph_strvector_init(igraph_strvector_t *sv, igraph_int_t size) {
72| |
73| 298k| sv->stor_begin = IGRAPH_CALLOC(size, const char *);
------------------
| | 33| 298k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 596k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 298k, False: 0]
| | | | | Branch (31:24): [True: 298k, False: 0]
| | | | | Branch (31:66): [True: 37.3k, False: 261k]
| | | | ------------------
| | ------------------
------------------
74| 298k| IGRAPH_CHECK_OOM(sv->stor_begin, "Cannot initialize string vector.");
------------------
| | 709| 298k| do { \
| | 710| 298k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 298k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 298k]
| | | | ------------------
| | ------------------
| | 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| 298k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 298k]
| | ------------------
------------------
75| |
76| 298k| sv->stor_end = sv->stor_begin + size;
77| 298k| sv->end = sv->stor_end;
78| |
79| 298k| return IGRAPH_SUCCESS;
80| 298k|}
igraph_strvector_destroy:
95| 298k|void igraph_strvector_destroy(igraph_strvector_t *sv) {
96| 298k| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 298k| do { \
| | 925| 298k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 298k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 298k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 298k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 298k]
| | ------------------
------------------
97| 298k| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 298k| do { \
| | 925| 298k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 298k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 298k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 298k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 298k]
| | ------------------
------------------
98| 3.02M| for (const char **ptr = sv->stor_begin; ptr < sv->end; ptr++) {
------------------
| Branch (98:45): [True: 2.72M, False: 298k]
------------------
99| 2.72M| IGRAPH_FREE(*ptr);
------------------
| | 36| 2.72M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
100| 2.72M| }
101| | IGRAPH_FREE(sv->stor_begin);
------------------
| | 36| 298k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
102| 298k|}
igraph_strvector_get:
117| 18.5M|const char *igraph_strvector_get(const igraph_strvector_t *sv, igraph_int_t idx) {
118| 18.5M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 18.5M| do { \
| | 925| 18.5M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 18.5M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 18.5M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 18.5M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 18.5M]
| | ------------------
------------------
119| 18.5M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 18.5M| do { \
| | 925| 18.5M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 18.5M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 18.5M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 18.5M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 18.5M]
| | ------------------
------------------
120| 18.5M| return sv->stor_begin[idx] ? sv->stor_begin[idx] : "";
------------------
| Branch (120:12): [True: 18.1M, False: 389k]
------------------
121| 18.5M|}
igraph_strvector_set:
141| 2.04M| const char *value) {
142| 2.04M| return igraph_strvector_set_len(sv, idx, value, strlen(value));
143| 2.04M|}
igraph_strvector_set_len:
163| 2.04M| const char *value, size_t len) {
164| 2.04M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 2.04M| do { \
| | 925| 2.04M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.04M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.04M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.04M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.04M]
| | ------------------
------------------
165| 2.04M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 2.04M| do { \
| | 925| 2.04M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.04M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.04M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.04M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.04M]
| | ------------------
------------------
166| |
167| 2.04M| if (sv->stor_begin[idx] == NULL) {
------------------
| Branch (167:9): [True: 2.02M, False: 17.2k]
------------------
168| 2.02M| sv->stor_begin[idx] = strndup(value, len);
169| 2.02M| IGRAPH_CHECK_OOM(sv->stor_begin[idx], "Cannot reserve space for new item in string vector.");
------------------
| | 709| 2.02M| do { \
| | 710| 2.02M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 2.02M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.02M]
| | | | ------------------
| | ------------------
| | 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.02M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 2.02M]
| | ------------------
------------------
170| 2.02M| } else {
171| 17.2k| char *tmp = IGRAPH_REALLOC(sv->stor_begin[idx], len + 1, char);
------------------
| | 35| 17.2k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 34.4k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 17.2k, False: 0]
| | | | | Branch (31:24): [True: 17.2k, False: 0]
| | | | | Branch (31:66): [True: 17.2k, False: 0]
| | | | ------------------
| | ------------------
------------------
172| 17.2k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new item in string vector.");
------------------
| | 709| 17.2k| do { \
| | 710| 17.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 17.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 17.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 17.2k]
| | ------------------
------------------
173| |
174| 17.2k| memcpy(tmp, value, len * sizeof(char));
175| 17.2k| tmp[len] = '\0';
176| 17.2k| sv->stor_begin[idx] = tmp;
177| 17.2k| }
178| |
179| 2.04M| return IGRAPH_SUCCESS;
180| 2.04M|}
igraph_strvector_append:
300| 36.3k| const igraph_strvector_t *from) {
301| 36.3k| const igraph_int_t to_size = igraph_strvector_size(to);
302| 36.3k| const igraph_int_t from_size = igraph_strvector_size(from);
303| 36.3k| const igraph_int_t to_capacity = igraph_strvector_capacity(to);
304| 36.3k| igraph_int_t new_to_size;
305| 36.3k| igraph_bool_t error = false;
306| 36.3k| const char *tmp;
307| |
308| 36.3k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 36.3k| do { \
| | 48| 36.3k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 36.3k| igraph_int_t _safe_sum; \
| | 50| 36.3k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 36.3k]
| | ------------------
| | 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| 36.3k| *(res) = _safe_sum; \
| | 54| 36.3k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 36.3k]
| | ------------------
------------------
309| |
310| 36.3k| if (to_capacity < new_to_size) {
------------------
| Branch (310:9): [True: 28.3k, False: 8.00k]
------------------
311| 28.3k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 28.3k|# 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| 28.3k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (311:40): [True: 28.3k, False: 0]
------------------
312| 28.3k| if (new_to_capacity < new_to_size) {
------------------
| Branch (312:13): [True: 28.3k, False: 4]
------------------
313| 28.3k| new_to_capacity = new_to_size;
314| 28.3k| }
315| 28.3k| IGRAPH_CHECK(igraph_strvector_reserve(to, new_to_capacity));
------------------
| | 656| 28.3k| do { \
| | 657| 28.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 28.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 28.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.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| 28.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 28.3k]
| | ------------------
------------------
316| 28.3k| }
317| |
318| 1.41M| for (igraph_int_t i = 0; i < from_size; i++) {
------------------
| Branch (318:30): [True: 1.37M, False: 36.3k]
------------------
319| 1.37M| if (from->stor_begin[i] == NULL || from->stor_begin[i][0] == '\0') {
------------------
| Branch (319:13): [True: 162k, False: 1.21M]
| Branch (319:44): [True: 269k, False: 946k]
------------------
320| | /* Represent empty strings as NULL. */
321| 432k| tmp = NULL;
322| 946k| } else {
323| 946k| tmp = strdup(from->stor_begin[i]);
324| 946k| if (tmp == NULL) {
------------------
| Branch (324:17): [True: 0, False: 946k]
------------------
325| 0| error = true;
326| 0| break;
327| 0| }
328| 946k| }
329| 1.37M| *(to->end) = tmp;
330| 1.37M| to->end++;
331| 1.37M| }
332| |
333| 36.3k| if (error) {
------------------
| Branch (333:9): [True: 0, False: 36.3k]
------------------
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| 36.3k| return IGRAPH_SUCCESS;
339| 36.3k|}
igraph_strvector_clear:
393| 1.04M|void igraph_strvector_clear(igraph_strvector_t *sv) {
394| 1.04M| igraph_int_t n = igraph_strvector_size(sv);
395| |
396| 2.09M| for (igraph_int_t i = 0; i < n; i++) {
------------------
| Branch (396:30): [True: 1.04M, False: 1.04M]
------------------
397| | IGRAPH_FREE(sv->stor_begin[i]);
------------------
| | 36| 1.04M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
398| 1.04M| }
399| 1.04M| sv->end = sv->stor_begin;
400| 1.04M|}
igraph_strvector_resize:
419| 3.44M|igraph_error_t igraph_strvector_resize(igraph_strvector_t *sv, igraph_int_t newsize) {
420| 3.44M| igraph_int_t toadd = newsize - igraph_strvector_size(sv);
421| 3.44M| igraph_int_t oldsize = igraph_strvector_size(sv);
422| |
423| 3.44M| if (newsize < oldsize) {
------------------
| Branch (423:9): [True: 1.90M, False: 1.53M]
------------------
424| 3.81M| for (igraph_int_t i = newsize; i < oldsize; i++) {
------------------
| Branch (424:40): [True: 1.90M, False: 1.90M]
------------------
425| 1.90M| IGRAPH_FREE(sv->stor_begin[i]);
------------------
| | 36| 1.90M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
426| 1.90M| }
427| 1.90M| sv->end = sv->stor_begin + newsize;
428| 1.90M| } else if (newsize > oldsize) {
------------------
| Branch (428:16): [True: 1.51M, False: 22.2k]
------------------
429| 1.51M| IGRAPH_CHECK(igraph_strvector_reserve(sv, newsize));
------------------
| | 656| 1.51M| do { \
| | 657| 1.51M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.51M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.51M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.51M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.51M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.51M]
| | ------------------
------------------
430| 1.51M| memset(sv->stor_begin + oldsize, 0, toadd * sizeof(const char *));
431| 1.51M| sv->end = sv->stor_begin + newsize;
432| 1.51M| }
433| |
434| 3.44M| return IGRAPH_SUCCESS;
435| 3.44M|}
igraph_strvector_capacity:
448| 1.71M|igraph_int_t igraph_strvector_capacity(const igraph_strvector_t *sv) {
449| 1.71M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 1.71M| do { \
| | 925| 1.71M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.71M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.71M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.71M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.71M]
| | ------------------
------------------
450| 1.71M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 1.71M| do { \
| | 925| 1.71M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.71M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.71M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.71M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.71M]
| | ------------------
------------------
451| 1.71M| return sv->stor_end - sv->stor_begin;
452| 1.71M|}
igraph_strvector_reserve:
481| 1.67M|igraph_error_t igraph_strvector_reserve(igraph_strvector_t *sv, igraph_int_t capacity) {
482| 1.67M| igraph_int_t current_capacity = igraph_strvector_capacity(sv);
483| |
484| 1.67M| if (capacity <= current_capacity) {
------------------
| Branch (484:9): [True: 1.02M, False: 650k]
------------------
485| 1.02M| return IGRAPH_SUCCESS;
486| 1.02M| }
487| |
488| 650k| const char **tmp = IGRAPH_REALLOC(sv->stor_begin, capacity, const char *);
------------------
| | 35| 650k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 1.30M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 650k, False: 0]
| | | | | Branch (31:24): [True: 650k, False: 0]
| | | | | Branch (31:66): [True: 650k, False: 0]
| | | | ------------------
| | ------------------
------------------
489| 650k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new items in string vector.");
------------------
| | 709| 650k| do { \
| | 710| 650k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 650k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 650k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 650k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 650k]
| | ------------------
------------------
490| |
491| 650k| sv->end = tmp + (sv->end - sv->stor_begin);
492| 650k| sv->stor_begin = tmp;
493| 650k| sv->stor_end = sv->stor_begin + capacity;
494| |
495| 650k| return IGRAPH_SUCCESS;
496| 650k|}
igraph_strvector_size:
538| 13.9M|igraph_int_t igraph_strvector_size(const igraph_strvector_t *sv) {
539| 13.9M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 13.9M| do { \
| | 925| 13.9M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 13.9M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.9M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 13.9M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 13.9M]
| | ------------------
------------------
540| 13.9M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 13.9M| do { \
| | 925| 13.9M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 13.9M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.9M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 13.9M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 13.9M]
| | ------------------
------------------
541| 13.9M| return sv->end - sv->stor_begin;
542| 13.9M|}
igraph_strvector_push_back:
580| 2.17M|igraph_error_t igraph_strvector_push_back(igraph_strvector_t *sv, const char *value) {
581| 2.17M| IGRAPH_CHECK(strvector_expand_if_full(sv));
------------------
| | 656| 2.17M| do { \
| | 657| 2.17M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.17M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.17M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.17M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.17M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.17M]
| | ------------------
------------------
582| 2.17M| const char *tmp = strdup(value);
583| 2.17M| IGRAPH_CHECK_OOM(tmp, "Cannot push new string to string vector.");
------------------
| | 709| 2.17M| do { \
| | 710| 2.17M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 2.17M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.17M]
| | | | ------------------
| | ------------------
| | 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.17M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 2.17M]
| | ------------------
------------------
584| 2.17M| *sv->end = tmp;
585| 2.17M| sv->end++;
586| |
587| 2.17M| return IGRAPH_SUCCESS;
588| 2.17M|}
igraph_strvector_update:
698| 13.1k|) {
699| 13.1k| igraph_strvector_clear(to);
700| 13.1k| IGRAPH_CHECK(igraph_strvector_append(to, from));
------------------
| | 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]
| | ------------------
------------------
701| 13.1k| return IGRAPH_SUCCESS;
702| 13.1k|}
strvector.c:strvector_expand_if_full:
548| 2.17M|static igraph_error_t strvector_expand_if_full(igraph_strvector_t *sv) {
549| 2.17M| IGRAPH_ASSERT(sv != NULL);
------------------
| | 924| 2.17M| do { \
| | 925| 2.17M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.17M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.17M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.17M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.17M]
| | ------------------
------------------
550| 2.17M| IGRAPH_ASSERT(sv->stor_begin != NULL);
------------------
| | 924| 2.17M| do { \
| | 925| 2.17M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.17M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.17M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.17M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.17M]
| | ------------------
------------------
551| |
552| 2.17M| if (sv->stor_end == sv->end) {
------------------
| Branch (552:9): [True: 130k, False: 2.04M]
------------------
553| 130k| igraph_int_t old_size = igraph_strvector_size(sv);
554| 130k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 130k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 130k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (554:33): [True: 130k, False: 0]
------------------
555| 130k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 130k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (555:13): [True: 0, False: 130k]
------------------
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| 130k| if (new_size == 0) {
------------------
| Branch (558:13): [True: 38.8k, False: 91.4k]
------------------
559| 38.8k| new_size = 1;
560| 38.8k| }
561| 130k| IGRAPH_CHECK(igraph_strvector_reserve(sv, new_size));
------------------
| | 656| 130k| do { \
| | 657| 130k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 130k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 130k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 130k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 130k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 130k]
| | ------------------
------------------
562| 130k| }
563| |
564| 2.17M| return IGRAPH_SUCCESS;
565| 2.17M|}
igraph_trie_init:
61| 120k|igraph_error_t igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) {
62| 120k| t->maxvalue = -1;
63| 120k| t->storekeys = storekeys;
64| 120k| IGRAPH_CHECK(igraph_i_trie_init_node(&t->node));
------------------
| | 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]
| | ------------------
------------------
65| 120k| IGRAPH_FINALLY(igraph_i_trie_destroy_node, &t->node);
------------------
| | 603| 120k| do { \
| | 604| 120k| /* the following branch makes the compiler check the compatibility of \
| | 605| 120k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 120k| * incorrect destructor function with the pointer */ \
| | 607| 120k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 120k]
| | ------------------
| | 608| 120k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 120k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 120k]
| | ------------------
------------------
66| 120k| if (storekeys) {
------------------
| Branch (66:9): [True: 31.8k, False: 89.0k]
------------------
67| 31.8k| IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0));
------------------
| | 656| 31.8k| do { \
| | 657| 31.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 31.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 31.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 31.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| 31.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 31.8k]
| | ------------------
------------------
68| 31.8k| }
69| |
70| 120k| IGRAPH_FINALLY_CLEAN(1);
71| 120k| return IGRAPH_SUCCESS;
72| 120k|}
igraph_trie_destroy:
102| 120k|void igraph_trie_destroy(igraph_trie_t *t) {
103| 120k| if (t->storekeys) {
------------------
| Branch (103:9): [True: 31.8k, False: 89.0k]
------------------
104| 31.8k| igraph_strvector_destroy(&t->keys);
105| 31.8k| }
106| 120k| igraph_i_trie_destroy_node(&t->node);
107| 120k|}
igraph_trie_get:
298| 2.84M|igraph_error_t igraph_trie_get(igraph_trie_t *t, const char *key, igraph_int_t *id) {
299| 2.84M| assert(key != NULL);
------------------
| Branch (299:5): [True: 0, False: 2.84M]
| Branch (299:5): [True: 2.84M, False: 0]
------------------
300| |
301| 2.84M| if (*key == '\0') {
------------------
| Branch (301:9): [True: 4, False: 2.84M]
------------------
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| 2.84M| if (!t->storekeys) {
------------------
| Branch (305:9): [True: 815k, False: 2.02M]
------------------
306| 815k| IGRAPH_CHECK(igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id));
------------------
| | 656| 815k| do { \
| | 657| 815k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 815k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 815k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 815k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 815k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 815k]
| | ------------------
------------------
307| 815k| if (*id > t->maxvalue) {
------------------
| Branch (307:13): [True: 55.1k, False: 760k]
------------------
308| 55.1k| t->maxvalue = *id;
309| 55.1k| }
310| 2.02M| } else {
311| 2.02M| igraph_error_t ret;
312| |
313| 2.02M| IGRAPH_FINALLY_ENTER();
314| | /* Add it to the string vector first, we can undo this later */
315| 2.02M| ret = igraph_strvector_push_back(&t->keys, key);
316| 2.02M| if (ret != IGRAPH_SUCCESS) {
------------------
| Branch (316:13): [True: 0, False: 2.02M]
------------------
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.02M| ret = igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id);
321| 2.02M| if (ret != IGRAPH_SUCCESS) {
------------------
| Branch (321:13): [True: 0, False: 2.02M]
------------------
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.02M| if (*id > t->maxvalue) {
------------------
| Branch (328:13): [True: 119k, False: 1.90M]
------------------
329| 119k| t->maxvalue = *id;
330| 1.90M| } else {
331| 1.90M| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */
332| 1.90M| }
333| 2.02M| IGRAPH_FINALLY_EXIT();
334| 2.02M| }
335| |
336| 2.84M| return IGRAPH_SUCCESS;
337| 2.84M|}
igraph_trie_get_len:
357| 849k| igraph_int_t *id) {
358| |
359| 849k| char *tmp = strndup(key, length);
360| 849k| IGRAPH_CHECK_OOM(tmp, "Cannot get from trie.");
------------------
| | 709| 849k| do { \
| | 710| 849k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 849k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 849k]
| | | | ------------------
| | ------------------
| | 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| 849k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 849k]
| | ------------------
------------------
361| 849k| IGRAPH_FINALLY(igraph_free, tmp);
------------------
| | 603| 849k| do { \
| | 604| 849k| /* the following branch makes the compiler check the compatibility of \
| | 605| 849k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 849k| * incorrect destructor function with the pointer */ \
| | 607| 849k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 849k]
| | ------------------
| | 608| 849k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 849k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 849k]
| | ------------------
------------------
362| 849k| IGRAPH_CHECK(igraph_trie_get(t, tmp, id));
------------------
| | 656| 849k| do { \
| | 657| 849k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 849k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 849k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 849k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 849k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 849k]
| | ------------------
------------------
363| 849k| IGRAPH_FREE(tmp);
------------------
| | 36| 849k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
364| 849k| IGRAPH_FINALLY_CLEAN(1);
365| |
366| 849k| return IGRAPH_SUCCESS;
367| 849k|}
igraph_trie_check:
383| 945k|igraph_error_t igraph_trie_check(igraph_trie_t *t, const char *key, igraph_int_t *id) {
384| 945k| IGRAPH_CHECK(igraph_i_trie_get_node(&t->node, key, -1, id));
------------------
| | 656| 945k| do { \
| | 657| 945k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 945k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 945k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 945k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 945k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 945k]
| | ------------------
------------------
385| 945k| return IGRAPH_SUCCESS;
386| 945k|}
igraph_trie_size:
413| 421k|igraph_int_t igraph_trie_size(igraph_trie_t *t) {
414| 421k| return t->maxvalue + 1;
415| 421k|}
igraph_i_trie_borrow_keys:
432| 10.4k|const igraph_strvector_t* igraph_i_trie_borrow_keys(igraph_trie_t *t) {
433| 10.4k| return &t->keys;
434| 10.4k|}
trie.c:igraph_i_trie_init_node:
41| 120k|static igraph_error_t igraph_i_trie_init_node(igraph_trie_node_t *t) {
42| 120k| IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0);
------------------
| | 62| 120k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 63| 120k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 120k| do { \
| | | | 604| 120k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 120k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 120k| * incorrect destructor function with the pointer */ \
| | | | 607| 120k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 120k]
| | | | ------------------
| | | | 608| 120k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 120k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 120k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 120k]
| | ------------------
------------------
43| 120k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0);
------------------
| | 46| 120k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 47| 120k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 120k| do { \
| | | | 604| 120k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 120k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 120k| * incorrect destructor function with the pointer */ \
| | | | 607| 120k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 120k]
| | | | ------------------
| | | | 608| 120k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 120k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 120k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 120k]
| | ------------------
------------------
44| 120k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->values, 0);
------------------
| | 119| 120k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 120| 120k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 120k| do { \
| | | | 604| 120k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 120k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 120k| * incorrect destructor function with the pointer */ \
| | | | 607| 120k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 120k]
| | | | ------------------
| | | | 608| 120k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 120k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 120k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 120k]
| | ------------------
------------------
45| 120k| IGRAPH_FINALLY_CLEAN(3);
46| 120k| return IGRAPH_SUCCESS;
47| 120k|}
trie.c:igraph_i_trie_destroy_node:
91| 120k|static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) {
92| | igraph_i_trie_destroy_node_helper(t, false);
93| 120k|}
trie.c:igraph_i_trie_destroy_node_helper:
74| 146k|static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) {
75| 146k| igraph_strvector_destroy(&t->strs);
76| 146k| igraph_int_t children_size = igraph_vector_ptr_size(&t->children);
77| 334k| for (igraph_int_t i = 0; i < children_size; i++) {
------------------
| Branch (77:30): [True: 188k, False: 146k]
------------------
78| 188k| igraph_trie_node_t *child = VECTOR(t->children)[i];
------------------
| | 60| 188k|#define VECTOR(v) ((v).stor_begin)
------------------
79| 188k| if (child != NULL) {
------------------
| Branch (79:13): [True: 25.3k, False: 162k]
------------------
80| 25.3k| igraph_i_trie_destroy_node_helper(child, true);
81| 25.3k| }
82| 188k| }
83| 146k| igraph_vector_ptr_destroy(&t->children);
84| 146k| igraph_vector_int_destroy(&t->values);
85| 146k| if (sfree) {
------------------
| Branch (85:9): [True: 25.3k, False: 120k]
------------------
86| | IGRAPH_FREE(t);
------------------
| | 36| 25.3k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
87| 25.3k| }
88| 146k|}
trie.c:igraph_i_trie_get_node:
129| 5.81M|) {
130| 5.81M| assert(key != NULL);
------------------
| Branch (130:5): [True: 0, False: 5.81M]
| Branch (130:5): [True: 5.81M, False: 0]
------------------
131| |
132| | /* If newvalue is negative, we don't add the node if nonexistent, only check
133| | * for its existence */
134| 5.81M| igraph_bool_t add = (newvalue >= 0);
135| |
136| 5.81M| igraph_int_t strs_size = igraph_strvector_size(&t->strs);
137| 15.1M| for (igraph_int_t i = 0; i < strs_size; i++) {
------------------
| Branch (137:30): [True: 14.9M, False: 162k]
------------------
138| 14.9M| size_t diff;
139| 14.9M| const char *str = igraph_strvector_get(&t->strs, i);
140| 14.9M| diff = igraph_i_strdiff(str, key);
141| |
142| 14.9M| if (diff == 0) {
------------------
| Branch (142:13): [True: 9.30M, False: 5.64M]
------------------
143| |
144| | /* ------------------------------------ */
145| | /* No match, next */
146| |
147| 9.30M| } else if (str[diff] == '\0' && key[diff] == '\0') {
------------------
| Branch (147:20): [True: 5.62M, False: 18.4k]
| Branch (147:41): [True: 3.59M, False: 2.03M]
------------------
148| |
149| | /* ------------------------------------ */
150| | /* They are exactly the same */
151| 3.59M| if (VECTOR(t->values)[i] != -1) {
------------------
| | 60| 3.59M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (151:17): [True: 3.59M, False: 663]
------------------
152| 3.59M| *id = VECTOR(t->values)[i];
------------------
| | 60| 3.59M|#define VECTOR(v) ((v).stor_begin)
------------------
153| 3.59M| return IGRAPH_SUCCESS;
154| 3.59M| } else {
155| 663| VECTOR(t->values)[i] = newvalue;
------------------
| | 60| 663|#define VECTOR(v) ((v).stor_begin)
------------------
156| 663| *id = newvalue;
157| 663| return IGRAPH_SUCCESS;
158| 663| }
159| |
160| 3.59M| } else if (str[diff] == '\0') {
------------------
| Branch (160:20): [True: 2.03M, False: 18.4k]
------------------
161| |
162| | /* ------------------------------------ */
163| | /* str is prefix of key, follow its link if there is one */
164| 2.03M| igraph_trie_node_t *node = VECTOR(t->children)[i];
------------------
| | 60| 2.03M|#define VECTOR(v) ((v).stor_begin)
------------------
165| 2.03M| if (node != NULL) {
------------------
| Branch (165:17): [True: 2.02M, False: 9.64k]
------------------
166| 2.02M| return igraph_i_trie_get_node(node, key + diff, newvalue, id);
167| 2.02M| } else if (add) {
------------------
| Branch (167:24): [True: 9.23k, False: 408]
------------------
168| 9.23k| igraph_trie_node_t *new_node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 9.23k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 18.4k| (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.23k, Folded]
| | | | ------------------
| | ------------------
------------------
169| 9.23k| IGRAPH_CHECK_OOM(new_node, "Cannot add to trie.");
------------------
| | 709| 9.23k| do { \
| | 710| 9.23k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 9.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.23k]
| | | | ------------------
| | ------------------
| | 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.23k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 9.23k]
| | ------------------
------------------
170| 9.23k| IGRAPH_FINALLY(igraph_free, new_node);
------------------
| | 603| 9.23k| do { \
| | 604| 9.23k| /* the following branch makes the compiler check the compatibility of \
| | 605| 9.23k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 9.23k| * incorrect destructor function with the pointer */ \
| | 607| 9.23k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 9.23k]
| | ------------------
| | 608| 9.23k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 9.23k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 9.23k]
| | ------------------
------------------
171| |
172| 9.23k| IGRAPH_STRVECTOR_INIT_FINALLY(&new_node->strs, 1);
------------------
| | 62| 9.23k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 9.23k| do { \
| | | | 657| 9.23k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.23k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.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| 9.23k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.23k]
| | | | ------------------
| | ------------------
| | 63| 9.23k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 9.23k| do { \
| | | | 604| 9.23k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.23k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.23k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.23k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.23k]
| | | | ------------------
| | | | 608| 9.23k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.23k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.23k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 9.23k]
| | ------------------
------------------
173| 9.23k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&new_node->children, 1);
------------------
| | 46| 9.23k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 9.23k| do { \
| | | | 657| 9.23k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.23k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.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| 9.23k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.23k]
| | | | ------------------
| | ------------------
| | 47| 9.23k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 9.23k| do { \
| | | | 604| 9.23k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.23k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.23k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.23k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.23k]
| | | | ------------------
| | | | 608| 9.23k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.23k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.23k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 9.23k]
| | ------------------
------------------
174| 9.23k| IGRAPH_VECTOR_INT_INIT_FINALLY(&new_node->values, 1);
------------------
| | 119| 9.23k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 9.23k| do { \
| | | | 657| 9.23k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 9.23k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 9.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 9.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| 9.23k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 9.23k]
| | | | ------------------
| | ------------------
| | 120| 9.23k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 9.23k| do { \
| | | | 604| 9.23k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 9.23k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 9.23k| * incorrect destructor function with the pointer */ \
| | | | 607| 9.23k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 9.23k]
| | | | ------------------
| | | | 608| 9.23k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 9.23k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 9.23k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 9.23k]
| | ------------------
------------------
175| 9.23k| IGRAPH_CHECK(igraph_strvector_set(&new_node->strs, 0, key + diff));
------------------
| | 656| 9.23k| do { \
| | 657| 9.23k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 9.23k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 9.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 9.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| 9.23k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 9.23k]
| | ------------------
------------------
176| 9.23k| IGRAPH_FINALLY_CLEAN(4);
177| |
178| 9.23k| VECTOR(new_node->children)[0] = 0;
------------------
| | 60| 9.23k|#define VECTOR(v) ((v).stor_begin)
------------------
179| 9.23k| VECTOR(new_node->values)[0] = newvalue;
------------------
| | 60| 9.23k|#define VECTOR(v) ((v).stor_begin)
------------------
180| |
181| 9.23k| VECTOR(t->children)[i] = new_node;
------------------
| | 60| 9.23k|#define VECTOR(v) ((v).stor_begin)
------------------
182| |
183| 9.23k| *id = newvalue;
184| 9.23k| return IGRAPH_SUCCESS;
185| 9.23k| } else {
186| 408| *id = -1;
187| 408| return IGRAPH_SUCCESS;
188| 408| }
189| |
190| 2.03M| } else if (key[diff] == '\0' && add) {
------------------
| Branch (190:20): [True: 2.20k, False: 16.2k]
| Branch (190:41): [True: 1.81k, False: 390]
------------------
191| |
192| | /* ------------------------------------ */
193| | /* key is prefix of str, the node has to be cut */
194| 1.81k| char *str2;
195| |
196| 1.81k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 1.81k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 3.63k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 1.81k, Folded]
| | | | ------------------
| | ------------------
------------------
197| 1.81k| IGRAPH_CHECK_OOM(node, "Cannot add to trie.");
------------------
| | 709| 1.81k| do { \
| | 710| 1.81k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.81k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 1.81k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.81k]
| | ------------------
------------------
198| 1.81k| IGRAPH_FINALLY(igraph_free, node);
------------------
| | 603| 1.81k| do { \
| | 604| 1.81k| /* the following branch makes the compiler check the compatibility of \
| | 605| 1.81k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 1.81k| * incorrect destructor function with the pointer */ \
| | 607| 1.81k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 1.81k]
| | ------------------
| | 608| 1.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 1.81k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 1.81k]
| | ------------------
------------------
199| |
200| 1.81k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1);
------------------
| | 62| 1.81k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 1.81k| do { \
| | | | 657| 1.81k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 1.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 1.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| 1.81k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 1.81k]
| | | | ------------------
| | ------------------
| | 63| 1.81k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 1.81k| do { \
| | | | 604| 1.81k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.81k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.81k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.81k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.81k]
| | | | ------------------
| | | | 608| 1.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.81k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.81k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 1.81k]
| | ------------------
------------------
201| 1.81k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1);
------------------
| | 46| 1.81k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 1.81k| do { \
| | | | 657| 1.81k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 1.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 1.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| 1.81k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 1.81k]
| | | | ------------------
| | ------------------
| | 47| 1.81k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 1.81k| do { \
| | | | 604| 1.81k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.81k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.81k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.81k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.81k]
| | | | ------------------
| | | | 608| 1.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.81k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.81k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 1.81k]
| | ------------------
------------------
202| 1.81k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1);
------------------
| | 119| 1.81k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 1.81k| do { \
| | | | 657| 1.81k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 1.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 1.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| 1.81k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 1.81k]
| | | | ------------------
| | ------------------
| | 120| 1.81k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 1.81k| do { \
| | | | 604| 1.81k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 1.81k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 1.81k| * incorrect destructor function with the pointer */ \
| | | | 607| 1.81k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 1.81k]
| | | | ------------------
| | | | 608| 1.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 1.81k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 1.81k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 1.81k]
| | ------------------
------------------
203| 1.81k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff));
------------------
| | 656| 1.81k| do { \
| | 657| 1.81k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.81k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.81k]
| | ------------------
------------------
204| |
205| 1.81k| VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 1.81k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 1.81k|#define VECTOR(v) ((v).stor_begin)
------------------
206| 1.81k| VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 1.81k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 1.81k|#define VECTOR(v) ((v).stor_begin)
------------------
207| |
208| 1.81k| str2 = strdup(str);
209| 1.81k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie.");
------------------
| | 709| 1.81k| do { \
| | 710| 1.81k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.81k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 1.81k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.81k]
| | ------------------
------------------
210| 1.81k| IGRAPH_FINALLY(igraph_free, str2);
------------------
| | 603| 1.81k| do { \
| | 604| 1.81k| /* the following branch makes the compiler check the compatibility of \
| | 605| 1.81k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 1.81k| * incorrect destructor function with the pointer */ \
| | 607| 1.81k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 1.81k]
| | ------------------
| | 608| 1.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 1.81k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 1.81k]
| | ------------------
------------------
211| 1.81k| str2[diff] = '\0';
212| |
213| 1.81k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2));
------------------
| | 656| 1.81k| do { \
| | 657| 1.81k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.81k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.81k]
| | ------------------
------------------
214| |
215| 1.81k| IGRAPH_FREE(str2);
------------------
| | 36| 1.81k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
216| 1.81k| IGRAPH_FINALLY_CLEAN(5);
217| |
218| 1.81k| VECTOR(t->values)[i] = newvalue;
------------------
| | 60| 1.81k|#define VECTOR(v) ((v).stor_begin)
------------------
219| 1.81k| VECTOR(t->children)[i] = node;
------------------
| | 60| 1.81k|#define VECTOR(v) ((v).stor_begin)
------------------
220| |
221| 1.81k| *id = newvalue;
222| 1.81k| return IGRAPH_SUCCESS;
223| |
224| 16.6k| } else if (add) {
------------------
| Branch (224:20): [True: 14.2k, False: 2.34k]
------------------
225| |
226| | /* ------------------------------------ */
227| | /* the first diff characters match */
228| 14.2k| char *str2;
229| |
230| 14.2k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
------------------
| | 33| 14.2k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 28.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 14.2k, Folded]
| | | | ------------------
| | ------------------
------------------
231| 14.2k| IGRAPH_CHECK_OOM(node, "Cannot add to trie.");
------------------
| | 709| 14.2k| do { \
| | 710| 14.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 14.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 14.2k]
| | ------------------
------------------
232| 14.2k| IGRAPH_FINALLY(igraph_free, node);
------------------
| | 603| 14.2k| do { \
| | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | 607| 14.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 14.2k]
| | ------------------
| | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 14.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 14.2k]
| | ------------------
------------------
233| |
234| 14.2k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2);
------------------
| | 62| 14.2k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 14.2k| do { \
| | | | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | 63| 14.2k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 14.2k| do { \
| | | | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 14.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 14.2k]
| | | | ------------------
| | | | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 14.2k]
| | ------------------
------------------
235| 14.2k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2);
------------------
| | 46| 14.2k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 14.2k| do { \
| | | | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | 47| 14.2k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 14.2k| do { \
| | | | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 14.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 14.2k]
| | | | ------------------
| | | | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 14.2k]
| | ------------------
------------------
236| 14.2k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 2);
------------------
| | 119| 14.2k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 14.2k| do { \
| | | | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | 120| 14.2k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 14.2k| do { \
| | | | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 14.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 14.2k]
| | | | ------------------
| | | | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 14.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 14.2k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 14.2k]
| | ------------------
------------------
237| 14.2k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
238| 14.2k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
239| 14.2k| VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->children)[0] = VECTOR(t->children)[i];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
240| 14.2k| VECTOR(node->children)[1] = 0;
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
241| 14.2k| VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(node->values)[0] = VECTOR(t->values)[i];
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
242| 14.2k| VECTOR(node->values)[1] = newvalue;
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
243| |
244| 14.2k| str2 = strdup(str);
245| 14.2k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie.");
------------------
| | 709| 14.2k| do { \
| | 710| 14.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 14.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 14.2k]
| | ------------------
------------------
246| |
247| 14.2k| str2[diff] = '\0';
248| 14.2k| IGRAPH_FINALLY(igraph_free, str2);
------------------
| | 603| 14.2k| do { \
| | 604| 14.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 14.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 14.2k| * incorrect destructor function with the pointer */ \
| | 607| 14.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 14.2k]
| | ------------------
| | 608| 14.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 14.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 14.2k]
| | ------------------
------------------
249| |
250| 14.2k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
251| |
252| 14.2k| IGRAPH_FREE(str2);
------------------
| | 36| 14.2k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
253| 14.2k| IGRAPH_FINALLY_CLEAN(5);
254| |
255| 14.2k| VECTOR(t->values)[i] = -1;
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
256| 14.2k| VECTOR(t->children)[i] = node;
------------------
| | 60| 14.2k|#define VECTOR(v) ((v).stor_begin)
------------------
257| |
258| 14.2k| *id = newvalue;
259| 14.2k| return IGRAPH_SUCCESS;
260| 14.2k| } else {
261| |
262| | /* ------------------------------------------------- */
263| | /* No match, but we requested not to add the new key */
264| 2.34k| *id = -1;
265| 2.34k| return IGRAPH_SUCCESS;
266| 2.34k| }
267| 14.9M| }
268| |
269| | /* ------------------------------------ */
270| | /* Nothing matches */
271| |
272| 162k| if (add) {
------------------
| Branch (272:9): [True: 148k, False: 13.4k]
------------------
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| 148k| IGRAPH_CHECK(igraph_strvector_push_back(&t->strs, key));
------------------
| | 656| 148k| do { \
| | 657| 148k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 148k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 148k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 148k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 148k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 148k]
| | ------------------
------------------
278| 148k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t->children, NULL));
------------------
| | 656| 148k| do { \
| | 657| 148k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 148k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 148k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 148k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 148k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 148k]
| | ------------------
------------------
279| 148k| IGRAPH_CHECK(igraph_vector_int_push_back(&t->values, newvalue));
------------------
| | 656| 148k| do { \
| | 657| 148k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 148k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 148k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 148k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 148k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 148k]
| | ------------------
------------------
280| 148k| *id = newvalue;
281| 148k| } else {
282| 13.4k| *id = -1;
283| 13.4k| }
284| |
285| 162k| return IGRAPH_SUCCESS;
286| 162k|}
trie.c:igraph_i_strdiff:
111| 14.9M|static size_t igraph_i_strdiff(const char *str, const char *key) {
112| 14.9M| size_t diff = 0;
113| 309M| while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) {
------------------
| Branch (113:12): [True: 306M, False: 3.59M]
| Branch (113:33): [True: 304M, False: 2.03M]
| Branch (113:54): [True: 294M, False: 9.32M]
------------------
114| 294M| diff++;
115| 294M| }
116| 14.9M| return diff;
117| 14.9M|}
igraph_attribute_record_list_init:
109| 92.0k|igraph_error_t FUNCTION(init)(TYPE *v, igraph_int_t size) {
110| 92.0k| igraph_int_t alloc_size = size > 0 ? size : 1;
------------------
| Branch (110:31): [True: 7.20k, False: 84.8k]
------------------
111| 92.0k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 92.0k| do { \
| | 925| 92.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 92.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 92.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 92.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 92.0k]
| | ------------------
------------------
112| 92.0k| v->stor_begin = IGRAPH_CALLOC(alloc_size, ITEM_TYPE);
------------------
| | 33| 92.0k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 184k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 92.0k, False: 0]
| | | | | Branch (31:24): [True: 92.0k, False: 0]
| | | | | Branch (31:66): [True: 92.0k, False: 0]
| | | | ------------------
| | ------------------
------------------
113| 92.0k| if (v->stor_begin == 0) {
------------------
| Branch (113:9): [True: 0, False: 92.0k]
------------------
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| 92.0k| v->stor_end = v->stor_begin + alloc_size;
117| 92.0k| v->end = v->stor_begin + size;
118| |
119| 92.0k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin, v->end));
------------------
| | 656| 92.0k| do { \
| | 657| 92.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 92.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 92.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 92.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| 92.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 92.0k]
| | ------------------
------------------
120| |
121| 92.0k| return IGRAPH_SUCCESS;
122| 92.0k|}
igraph_attribute_record_list_init_copy:
141| 10.6k|igraph_error_t FUNCTION(init_copy)(TYPE* to, const TYPE* from) {
142| 10.6k| igraph_int_t i, size = FUNCTION(size)(from);
------------------
| | 161| 10.6k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 10.6k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
143| |
144| 10.6k| IGRAPH_CHECK(FUNCTION(init)(to, 0));
------------------
| | 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]
| | ------------------
------------------
145| 10.6k| IGRAPH_FINALLY(FUNCTION(destroy), to);
------------------
| | 603| 10.6k| do { \
| | 604| 10.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 10.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 10.6k| * incorrect destructor function with the pointer */ \
| | 607| 10.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 10.6k]
| | ------------------
| | 608| 10.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 10.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 10.6k]
| | ------------------
------------------
146| |
147| 13.1k| for (i = 0; i < size; i++) {
------------------
| Branch (147:17): [True: 2.44k, False: 10.6k]
------------------
148| 2.44k| IGRAPH_CHECK(FUNCTION(push_back_copy)(to, FUNCTION(get_ptr)(from, i)));
------------------
| | 656| 2.44k| do { \
| | 657| 2.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.44k]
| | ------------------
------------------
149| 2.44k| }
150| |
151| 10.6k| IGRAPH_FINALLY_CLEAN(1);
152| |
153| 10.6k| return IGRAPH_SUCCESS;
154| 10.6k|}
igraph_attribute_record_list_destroy:
176| 92.0k|void FUNCTION(destroy)(TYPE *v) {
177| 92.0k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 92.0k| do { \
| | 925| 92.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 92.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 92.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 92.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 92.0k]
| | ------------------
------------------
178| |
179| 92.0k| if (v->stor_begin != 0) {
------------------
| Branch (179:9): [True: 92.0k, False: 0]
------------------
180| 92.0k| FUNCTION(clear)(v);
------------------
| | 161| 92.0k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 92.0k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
181| 92.0k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 92.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
182| | v->stor_begin = NULL;
183| 92.0k| }
184| 92.0k|}
igraph_attribute_record_list_capacity:
203| 14.2k|igraph_int_t FUNCTION(capacity)(const TYPE *v) {
204| 14.2k| return v->stor_end - v->stor_begin;
205| 14.2k|}
igraph_attribute_record_list_reserve:
233| 14.2k|igraph_error_t FUNCTION(reserve)(TYPE *v, igraph_int_t capacity) {
234| 14.2k| igraph_int_t current_capacity;
235| 14.2k| ITEM_TYPE *tmp;
------------------
| | 61| 14.2k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 14.2k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
236| |
237| 14.2k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 14.2k| do { \
| | 925| 14.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 14.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 14.2k]
| | ------------------
------------------
238| 14.2k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 14.2k| do { \
| | 925| 14.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 14.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 14.2k]
| | ------------------
------------------
239| 14.2k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 14.2k| do { \
| | 925| 14.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 14.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 14.2k]
| | ------------------
------------------
240| |
241| 14.2k| current_capacity = FUNCTION(capacity)(v);
------------------
| | 161| 14.2k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 14.2k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
242| |
243| 14.2k| if (capacity <= current_capacity) {
------------------
| Branch (243:9): [True: 0, False: 14.2k]
------------------
244| 0| return IGRAPH_SUCCESS;
245| 0| }
246| |
247| 14.2k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, ITEM_TYPE);
------------------
| | 35| 14.2k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 28.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 14.2k, False: 0]
| | | | | Branch (31:24): [True: 14.2k, False: 0]
| | | | | Branch (31:66): [True: 14.2k, False: 0]
| | | | ------------------
| | ------------------
------------------
248| 14.2k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for list.");
------------------
| | 709| 14.2k| do { \
| | 710| 14.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 14.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 14.2k]
| | ------------------
------------------
249| |
250| 14.2k| v->end = tmp + (v->end - v->stor_begin);
251| 14.2k| v->stor_begin = tmp;
252| 14.2k| v->stor_end = v->stor_begin + capacity;
253| |
254| 14.2k| return IGRAPH_SUCCESS;
255| 14.2k|}
igraph_attribute_record_list_size:
287| 1.86M|igraph_int_t FUNCTION(size)(const TYPE *v) {
288| 1.86M| IGRAPH_ASSERT(v != 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]
| | ------------------
------------------
289| 1.86M| IGRAPH_ASSERT(v->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]
| | ------------------
------------------
290| 1.86M| return v->end - v->stor_begin;
291| 1.86M|}
igraph_attribute_record_list_clear:
357| 92.0k|void FUNCTION(clear)(TYPE *v) {
358| 92.0k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 92.0k| do { \
| | 925| 92.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 92.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 92.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 92.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 92.0k]
| | ------------------
------------------
359| 92.0k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 92.0k| do { \
| | 925| 92.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 92.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 92.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 92.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 92.0k]
| | ------------------
------------------
360| 92.0k| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin, v->end);
------------------
| | 162| 92.0k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 92.0k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
361| 92.0k| v->end = v->stor_begin;
362| 92.0k|}
igraph_attribute_record_list_get_ptr:
377| 5.12M|ITEM_TYPE *FUNCTION(get_ptr)(const TYPE *v, igraph_int_t pos) {
378| 5.12M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 5.12M| do { \
| | 925| 5.12M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 5.12M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.12M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 5.12M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 5.12M]
| | ------------------
------------------
379| 5.12M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 5.12M| do { \
| | 925| 5.12M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 5.12M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.12M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 5.12M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 5.12M]
| | ------------------
------------------
380| 5.12M| return v->stor_begin + pos;
381| 5.12M|}
igraph_attribute_record_list_push_back:
587| 23.2k|igraph_error_t FUNCTION(push_back)(TYPE *v, ITEM_TYPE *e) {
588| 23.2k| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v));
------------------
| | 656| 23.2k| do { \
| | 657| 23.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 23.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 23.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 23.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 23.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 23.2k]
| | ------------------
------------------
589| 23.2k| *(v->end) = *e;
590| 23.2k| v->end += 1;
591| 23.2k| return IGRAPH_SUCCESS;
592| 23.2k|}
igraph_attribute_record_list_push_back_copy:
612| 2.44k|igraph_error_t FUNCTION(push_back_copy)(TYPE *v, const ITEM_TYPE *e) {
613| 2.44k| ITEM_TYPE copy;
------------------
| | 61| 2.44k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 2.44k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
614| 2.44k| IGRAPH_CHECK(INTERNAL_FUNCTION(copy_item)(©, e));
------------------
| | 656| 2.44k| do { \
| | 657| 2.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.44k]
| | ------------------
------------------
615| 2.44k| IGRAPH_FINALLY(INTERNAL_FUNCTION(destroy_item), ©);
------------------
| | 603| 2.44k| do { \
| | 604| 2.44k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.44k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.44k| * incorrect destructor function with the pointer */ \
| | 607| 2.44k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.44k]
| | ------------------
| | 608| 2.44k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.44k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.44k]
| | ------------------
------------------
616| 2.44k| IGRAPH_CHECK(FUNCTION(push_back)(v, ©));
------------------
| | 656| 2.44k| do { \
| | 657| 2.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.44k]
| | ------------------
------------------
617| 2.44k| IGRAPH_FINALLY_CLEAN(1);
618| 2.44k| return IGRAPH_SUCCESS;
619| 2.44k|}
igraph_attribute_record_list_push_back_new:
640| 34.4k|igraph_error_t FUNCTION(push_back_new)(TYPE *v, ITEM_TYPE** e) {
641| 34.4k| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v));
------------------
| | 656| 34.4k| do { \
| | 657| 34.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 34.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 34.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 34.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| 34.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 34.4k]
| | ------------------
------------------
642| 34.4k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_item)(v, v->end));
------------------
| | 656| 34.4k| do { \
| | 657| 34.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 34.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 34.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 34.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| 34.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 34.4k]
| | ------------------
------------------
643| 34.4k| if (e) {
------------------
| Branch (643:9): [True: 34.4k, False: 0]
------------------
644| 34.4k| *e = v->end;
645| 34.4k| }
646| 34.4k| v->end += 1;
647| 34.4k| return IGRAPH_SUCCESS;
648| 34.4k|}
attributes.c:igraph_i_attribute_record_list_init_slice:
1068| 92.0k|static igraph_error_t INTERNAL_FUNCTION(init_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) {
1069| 92.0k| ITEM_TYPE *current;
------------------
| | 61| 92.0k| #define ITEM_TYPE BASE
| | ------------------
| | | | 115| 92.0k| #define BASE igraph_attribute_record_t
| | ------------------
------------------
1070| 92.0k| igraph_error_t retval;
1071| |
1072| 99.2k| for (current = start; current < end; current++) {
------------------
| Branch (1072:27): [True: 7.20k, False: 92.0k]
------------------
1073| 7.20k| retval = INTERNAL_FUNCTION(init_item)(list, current);
------------------
| | 162| 7.20k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 7.20k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1074| 7.20k| if (retval) {
------------------
| Branch (1074:13): [True: 0, False: 7.20k]
------------------
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| 7.20k| }
1079| |
1080| 92.0k| return IGRAPH_SUCCESS;
1081| 92.0k|}
attributes.c:igraph_i_attribute_record_list_destroy_slice:
1083| 92.0k|static void INTERNAL_FUNCTION(destroy_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) {
1084| 92.0k| IGRAPH_UNUSED(list);
------------------
| | 30| 92.0k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1085| 156k| for (; start < end; start++) {
------------------
| Branch (1085:12): [True: 64.9k, False: 92.0k]
------------------
1086| 64.9k| INTERNAL_FUNCTION(destroy_item)(start);
------------------
| | 162| 64.9k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c)
| | ------------------
| | | | 19| 64.9k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1087| 64.9k| }
1088| 92.0k|}
attributes.c:igraph_i_attribute_record_list_expand_if_full:
1094| 57.6k|static igraph_error_t INTERNAL_FUNCTION(expand_if_full)(TYPE *v) {
1095| 57.6k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 57.6k| do { \
| | 925| 57.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 57.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 57.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 57.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 57.6k]
| | ------------------
------------------
1096| 57.6k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 57.6k| do { \
| | 925| 57.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 57.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 57.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 57.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 57.6k]
| | ------------------
------------------
1097| |
1098| 57.6k| if (v->stor_end == v->end) {
------------------
| Branch (1098:9): [True: 14.2k, False: 43.4k]
------------------
1099| 14.2k| igraph_int_t old_size = FUNCTION(size)(v);
------------------
| | 161| 14.2k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c)
| | ------------------
| | | | 19| 14.2k|#define CONCAT2x(a,b) a ## _ ## b
| | ------------------
------------------
1100| 14.2k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 14.2k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 14.2k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (1100:33): [True: 14.2k, False: 0]
------------------
1101| 14.2k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 14.2k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (1101:13): [True: 0, False: 14.2k]
------------------
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| 14.2k| if (new_size == 0) {
------------------
| Branch (1104:13): [True: 0, False: 14.2k]
------------------
1105| 0| new_size = 1;
1106| 0| }
1107| 14.2k| IGRAPH_CHECK(FUNCTION(reserve)(v, new_size));
------------------
| | 656| 14.2k| do { \
| | 657| 14.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 14.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.2k]
| | ------------------
------------------
1108| 14.2k| }
1109| |
1110| 57.6k| return IGRAPH_SUCCESS;
1111| 57.6k|}
igraph_vector_int_pair_order:
119| 35.1k| igraph_vector_int_t* res, igraph_int_t nodes) {
120| 35.1k| igraph_int_t edges = igraph_vector_int_size(v);
121| 35.1k| igraph_vector_int_t ptr;
122| 35.1k| igraph_vector_int_t rad;
123| 35.1k| igraph_int_t i, j;
124| |
125| 35.1k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 35.1k| do { \
| | 925| 35.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 35.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 35.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 35.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 35.1k]
| | ------------------
------------------
126| 35.1k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 35.1k| do { \
| | 925| 35.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 35.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 35.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 35.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 35.1k]
| | ------------------
------------------
127| |
128| 35.1k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1);
------------------
| | 119| 35.1k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 35.1k| do { \
| | | | 657| 35.1k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 35.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 35.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 35.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| 35.1k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 35.1k]
| | | | ------------------
| | ------------------
| | 120| 35.1k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 35.1k| do { \
| | | | 604| 35.1k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 35.1k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 35.1k| * incorrect destructor function with the pointer */ \
| | | | 607| 35.1k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 35.1k]
| | | | ------------------
| | | | 608| 35.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 35.1k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 35.1k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 35.1k]
| | ------------------
------------------
129| 35.1k| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges);
------------------
| | 119| 35.1k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 35.1k| do { \
| | | | 657| 35.1k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 35.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 35.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 35.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| 35.1k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 35.1k]
| | | | ------------------
| | ------------------
| | 120| 35.1k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 35.1k| do { \
| | | | 604| 35.1k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 35.1k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 35.1k| * incorrect destructor function with the pointer */ \
| | | | 607| 35.1k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 35.1k]
| | | | ------------------
| | | | 608| 35.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 35.1k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 35.1k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 35.1k]
| | ------------------
------------------
130| 35.1k| IGRAPH_CHECK(igraph_vector_int_resize(res, edges));
------------------
| | 656| 35.1k| do { \
| | 657| 35.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 35.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 35.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 35.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| 35.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 35.1k]
| | ------------------
------------------
131| |
132| 2.83M| for (i = 0; i < edges; i++) {
------------------
| Branch (132:17): [True: 2.79M, False: 35.1k]
------------------
133| 2.79M| igraph_int_t radix = VECTOR(*v2)[i];
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
134| 2.79M| if (VECTOR(ptr)[radix] != 0) {
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (134:13): [True: 2.63M, False: 161k]
------------------
135| 2.63M| VECTOR(rad)[i] = VECTOR(ptr)[radix];
------------------
| | 60| 2.63M|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(rad)[i] = VECTOR(ptr)[radix];
------------------
| | 60| 2.63M|#define VECTOR(v) ((v).stor_begin)
------------------
136| 2.63M| }
137| 2.79M| VECTOR(ptr)[radix] = i + 1;
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
138| 2.79M| }
139| |
140| 35.1k| j = 0;
141| 373k| for (i = 0; i < nodes + 1; i++) {
------------------
| Branch (141:17): [True: 338k, False: 35.1k]
------------------
142| 338k| if (VECTOR(ptr)[i] != 0) {
------------------
| | 60| 338k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (142:13): [True: 161k, False: 177k]
------------------
143| 161k| igraph_int_t next = VECTOR(ptr)[i] - 1;
------------------
| | 60| 161k|#define VECTOR(v) ((v).stor_begin)
------------------
144| 161k| VECTOR(*res)[j++] = next;
------------------
| | 60| 161k|#define VECTOR(v) ((v).stor_begin)
------------------
145| 2.79M| while (VECTOR(rad)[next] != 0) {
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (145:20): [True: 2.63M, False: 161k]
------------------
146| 2.63M| next = VECTOR(rad)[next] - 1;
------------------
| | 60| 2.63M|#define VECTOR(v) ((v).stor_begin)
------------------
147| 2.63M| VECTOR(*res)[j++] = next;
------------------
| | 60| 2.63M|#define VECTOR(v) ((v).stor_begin)
------------------
148| 2.63M| }
149| 161k| }
150| 338k| }
151| |
152| 35.1k| igraph_vector_int_null(&ptr);
153| 35.1k| igraph_vector_int_null(&rad);
154| |
155| 2.83M| for (i = 0; i < edges; i++) {
------------------
| Branch (155:17): [True: 2.79M, False: 35.1k]
------------------
156| 2.79M| igraph_int_t edge = VECTOR(*res)[edges - i - 1];
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
157| 2.79M| igraph_int_t radix = VECTOR(*v)[edge];
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
158| 2.79M| if (VECTOR(ptr)[radix] != 0) {
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (158:13): [True: 2.63M, False: 161k]
------------------
159| 2.63M| VECTOR(rad)[edge] = VECTOR(ptr)[radix];
------------------
| | 60| 2.63M|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(rad)[edge] = VECTOR(ptr)[radix];
------------------
| | 60| 2.63M|#define VECTOR(v) ((v).stor_begin)
------------------
160| 2.63M| }
161| 2.79M| VECTOR(ptr)[radix] = edge + 1;
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
162| 2.79M| }
163| |
164| 35.1k| j = 0;
165| 373k| for (i = 0; i < nodes + 1; i++) {
------------------
| Branch (165:17): [True: 338k, False: 35.1k]
------------------
166| 338k| if (VECTOR(ptr)[i] != 0) {
------------------
| | 60| 338k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (166:13): [True: 161k, False: 177k]
------------------
167| 161k| igraph_int_t next = VECTOR(ptr)[i] - 1;
------------------
| | 60| 161k|#define VECTOR(v) ((v).stor_begin)
------------------
168| 161k| VECTOR(*res)[j++] = next;
------------------
| | 60| 161k|#define VECTOR(v) ((v).stor_begin)
------------------
169| 2.79M| while (VECTOR(rad)[next] != 0) {
------------------
| | 60| 2.79M|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (169:20): [True: 2.63M, False: 161k]
------------------
170| 2.63M| next = VECTOR(rad)[next] - 1;
------------------
| | 60| 2.63M|#define VECTOR(v) ((v).stor_begin)
------------------
171| 2.63M| VECTOR(*res)[j++] = next;
------------------
| | 60| 2.63M|#define VECTOR(v) ((v).stor_begin)
------------------
172| 2.63M| }
173| 161k| }
174| 338k| }
175| |
176| 35.1k| igraph_vector_int_destroy(&ptr);
177| 35.1k| igraph_vector_int_destroy(&rad);
178| 35.1k| IGRAPH_FINALLY_CLEAN(2);
179| |
180| 35.1k| return IGRAPH_SUCCESS;
181| 35.1k|}
igraph_vector_init:
134| 34.1k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 34.1k| igraph_int_t alloc_size;
136| 34.1k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 34.1k| do { \
| | 925| 34.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 34.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 34.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 34.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 34.1k]
| | ------------------
------------------
137| 34.1k| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 11.3k, False: 22.7k]
------------------
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| 34.1k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 34.1k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 68.2k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 34.1k, False: 0]
| | | | | Branch (31:24): [True: 34.1k, False: 0]
| | | | | Branch (31:66): [True: 34.1k, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 34.1k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 34.1k| do { \
| | 710| 34.1k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 34.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 34.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| 34.1k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 34.1k]
| | ------------------
------------------
145| 34.1k| v->stor_end = v->stor_begin + alloc_size;
146| 34.1k| v->end = v->stor_begin + size;
147| |
148| 34.1k| return IGRAPH_SUCCESS;
149| 34.1k|}
igraph_vector_destroy:
408| 34.1k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 34.1k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 34.1k| do { \
| | 925| 34.1k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 34.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 34.1k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 34.1k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 34.1k]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 34.1k| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 34.1k, False: 0]
------------------
413| 34.1k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 34.1k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 34.1k| }
416| 34.1k|}
igraph_vector_capacity:
436| 388k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 388k| return v->stor_end - v->stor_begin;
438| 388k|}
igraph_vector_reserve:
468| 382k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 382k| igraph_int_t current_capacity;
470| 382k| BASE *tmp;
------------------
| | 29| 382k| #define BASE igraph_real_t
------------------
471| |
472| 382k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 382k| do { \
| | 925| 382k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 382k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 382k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 382k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 382k]
| | ------------------
------------------
473| 382k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 382k| do { \
| | 925| 382k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 382k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 382k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 382k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 382k]
| | ------------------
------------------
474| 382k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 382k| do { \
| | 925| 382k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 382k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 382k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 382k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 382k]
| | ------------------
------------------
475| |
476| 382k| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 170| 382k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 382k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 382k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
477| |
478| 382k| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 354k, False: 27.5k]
------------------
479| 354k| return IGRAPH_SUCCESS;
480| 354k| }
481| |
482| 27.5k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 27.5k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 55.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 27.5k, False: 0]
| | | | | Branch (31:24): [True: 27.5k, False: 0]
| | | | | Branch (31:66): [True: 27.5k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 27.5k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 27.5k| do { \
| | 710| 27.5k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 27.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.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| 27.5k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 27.5k]
| | ------------------
------------------
484| |
485| 27.5k| v->end = tmp + (v->end - v->stor_begin);
486| 27.5k| v->stor_begin = tmp;
487| 27.5k| v->stor_end = v->stor_begin + capacity;
488| |
489| 27.5k| return IGRAPH_SUCCESS;
490| 27.5k|}
igraph_vector_size:
522| 413k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 413k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 413k| do { \
| | 925| 413k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 413k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 413k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 413k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 413k]
| | ------------------
------------------
524| 413k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 413k| do { \
| | 925| 413k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 413k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 413k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 413k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 413k]
| | ------------------
------------------
525| 413k| return v->end - v->stor_begin;
526| 413k|}
igraph_vector_clear:
542| 353k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 353k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 353k| do { \
| | 925| 353k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 353k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 353k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 353k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 353k]
| | ------------------
------------------
544| 353k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 353k| do { \
| | 925| 353k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 353k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 353k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 353k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 353k]
| | ------------------
------------------
545| 353k| v->end = v->stor_begin;
546| 353k|}
igraph_vector_push_back:
573| 557k|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 557k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 557k| do { \
| | 925| 557k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 557k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 557k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 557k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 557k]
| | ------------------
------------------
575| 557k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 557k| do { \
| | 925| 557k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 557k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 557k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 557k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 557k]
| | ------------------
------------------
576| |
577| 557k| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 13.3k, False: 544k]
------------------
578| | /* full, allocate more storage */
579| 13.3k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 170| 13.3k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 13.3k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 13.3k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
580| 13.3k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 13.3k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 13.3k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 13.3k, False: 0]
------------------
581| 13.3k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 13.3k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 13.3k]
------------------
582| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
583| 0| }
584| 13.3k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 13.3k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 13.3k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 13.3k| do { \
| | 657| 13.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.3k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 13.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.3k]
| | ------------------
------------------
588| 13.3k| }
589| |
590| 557k| *(v->end) = e;
591| 557k| v->end += 1;
592| |
593| 557k| return IGRAPH_SUCCESS;
594| 557k|}
igraph_vector_sort:
958| 33|void FUNCTION(igraph_vector, sort)(TYPE(igraph_vector) *v) {
959| 33| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 33| do { \
| | 925| 33| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 33| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 33]
| | ------------------
------------------
960| 33| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 33| do { \
| | 925| 33| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 33| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 33]
| | ------------------
------------------
961| 33| igraph_qsort(v->stor_begin, FUNCTION(igraph_vector, size)(v),
------------------
| | 170| 33| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 33|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 33|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
962| 33| sizeof(BASE), FUNCTION(igraph_vector, sort_cmp));
------------------
| | 170| 33| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 33|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 33|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
963| 33|}
igraph_vector_resize:
1264| 364k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 364k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 364k| do { \
| | 925| 364k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 364k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 364k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 364k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 364k]
| | ------------------
------------------
1266| 364k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 364k| do { \
| | 925| 364k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 364k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 364k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 364k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 364k]
| | ------------------
------------------
1267| 364k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 364k| do { \
| | 657| 364k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 364k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 364k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 364k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 364k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 364k]
| | ------------------
------------------
1268| 364k| v->end = v->stor_begin + new_size;
1269| 364k| return IGRAPH_SUCCESS;
1270| 364k|}
igraph_vector_init_copy:
1538| 33|) {
1539| 33| igraph_int_t from_size;
1540| |
1541| 33| IGRAPH_ASSERT(from != NULL);
------------------
| | 924| 33| do { \
| | 925| 33| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 33| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 33]
| | ------------------
------------------
1542| 33| IGRAPH_ASSERT(from->stor_begin != NULL);
------------------
| | 924| 33| do { \
| | 925| 33| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 33| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 33]
| | ------------------
------------------
1543| |
1544| 33| from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 33| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 33|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 33|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
1545| 33| IGRAPH_CHECK(FUNCTION(igraph_vector, init)(to, from_size));
------------------
| | 656| 33| do { \
| | 657| 33| igraph_error_t igraph_i_ret = (expr); \
| | 658| 33| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 33| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 33]
| | ------------------
------------------
1546| |
1547| 33| memcpy(to->stor_begin, from->stor_begin, from_size * sizeof(BASE));
1548| |
1549| 33| return IGRAPH_SUCCESS;
1550| 33|}
igraph_vector_append:
2427| 6.37k| const TYPE(igraph_vector) *from) {
2428| 6.37k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 6.37k| do { \
| | 925| 6.37k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.37k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.37k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.37k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.37k]
| | ------------------
------------------
2429| 6.37k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 6.37k| do { \
| | 925| 6.37k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.37k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.37k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.37k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.37k]
| | ------------------
------------------
2430| |
2431| 6.37k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 170| 6.37k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 6.37k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 6.37k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2432| 6.37k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 6.37k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 6.37k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 6.37k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2433| 6.37k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 170| 6.37k| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 6.37k|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 6.37k|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2434| 6.37k| igraph_int_t new_to_size;
2435| |
2436| 6.37k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 6.37k| do { \
| | 48| 6.37k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 6.37k| igraph_int_t _safe_sum; \
| | 50| 6.37k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 6.37k]
| | ------------------
| | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \
| | ------------------
| | | | 464| 0| do { \
| | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | | | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | | | 467| 0| return igraph_errno; \
| | | | 468| 0| } while (0)
| | | | ------------------
| | | | | Branch (468:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 52| 0| } \
| | 53| 6.37k| *(res) = _safe_sum; \
| | 54| 6.37k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 6.37k]
| | ------------------
------------------
2437| |
2438| 6.37k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 4.77k, False: 1.59k]
------------------
2439| 4.77k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 4.77k|# 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.77k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 4.77k, False: 0]
------------------
2440| 4.77k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 3.65k, False: 1.12k]
------------------
2441| 3.65k| new_to_capacity = new_to_size;
2442| 3.65k| }
2443| 4.77k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 656| 4.77k| do { \
| | 657| 4.77k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.77k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.77k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.77k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.77k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.77k]
| | ------------------
------------------
2444| 4.77k| }
2445| |
2446| 6.37k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 6.37k| sizeof(BASE) * from_size);
2448| 6.37k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 6.37k| return IGRAPH_SUCCESS;
2451| 6.37k|}
igraph_vector_update:
2524| 314| const TYPE(igraph_vector) *from) {
2525| 314| igraph_int_t n = FUNCTION(igraph_vector, size)(from);
------------------
| | 170| 314| #define FUNCTION(a,c) CONCAT2(a,c)
| | ------------------
| | | | 20| 314|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 314|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2526| 314| IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, n));
------------------
| | 656| 314| do { \
| | 657| 314| igraph_error_t igraph_i_ret = (expr); \
| | 658| 314| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 314]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 314| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 314]
| | ------------------
------------------
2527| 314| memcpy(to->stor_begin, from->stor_begin, sizeof(BASE)*n);
2528| 314| return IGRAPH_SUCCESS;
2529| 314|}
igraph_vector_swap:
2541| 302|void FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) {
2542| |
2543| 302| TYPE(igraph_vector) tmp;
------------------
| | 171| 302| #define TYPE(a) CONCAT2(a,t)
| | ------------------
| | | | 20| 302|#define CONCAT2(a,b) CONCAT2x(a,b)
| | | | ------------------
| | | | | | 19| 302|#define CONCAT2x(a,b) a ## _ ## b
| | | | ------------------
| | ------------------
------------------
2544| |
2545| 302| tmp = *v1;
2546| 302| *v1 = *v2;
2547| 302| *v2 = tmp;
2548| 302|}
igraph_vector_char_init:
134| 1.28M|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 1.28M| igraph_int_t alloc_size;
136| 1.28M| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 1.28M| do { \
| | 925| 1.28M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.28M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.28M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.28M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.28M]
| | ------------------
------------------
137| 1.28M| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 1.25M, False: 32.0k]
------------------
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.28M| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 1.28M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 2.57M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 1.28M, False: 0]
| | | | | Branch (31:24): [True: 1.28M, False: 0]
| | | | | Branch (31:66): [True: 1.28M, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 1.28M| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 1.28M| do { \
| | 710| 1.28M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.28M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.28M]
| | | | ------------------
| | ------------------
| | 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.28M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.28M]
| | ------------------
------------------
145| 1.28M| v->stor_end = v->stor_begin + alloc_size;
146| 1.28M| v->end = v->stor_begin + size;
147| |
148| 1.28M| return IGRAPH_SUCCESS;
149| 1.28M|}
igraph_vector_char_view:
182| 40.9M| const BASE *data, igraph_int_t length) {
183| |
184| 40.9M| static const BASE dummy = ZERO;
------------------
| | 48| 40.9M| #define ZERO 0
------------------
185| 40.9M| TYPE(igraph_vector) v;
------------------
| | 179| 40.9M| #define TYPE(a) CONCAT3(a,SHORT,t)
| | ------------------
| | | | 22| 40.9M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 40.9M|#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.9M| if (length == 0) {
------------------
| Branch (190:9): [True: 194, False: 40.9M]
------------------
191| 194| data = &dummy;
192| 40.9M| } else {
193| 40.9M| IGRAPH_ASSERT(data != NULL);
------------------
| | 924| 40.9M| do { \
| | 925| 40.9M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 40.9M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 40.9M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 40.9M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 40.9M]
| | ------------------
------------------
194| 40.9M| }
195| |
196| 40.9M| v.stor_begin = (BASE*)data;
197| 40.9M| v.stor_end = (BASE*)data + length;
198| 40.9M| v.end = v.stor_end;
199| 40.9M| return v;
200| 40.9M|}
igraph_vector_char_destroy:
408| 1.28M|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 1.28M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.28M| do { \
| | 925| 1.28M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.28M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.28M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.28M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.28M]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 1.28M| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 1.28M, False: 0]
------------------
413| 1.28M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 1.28M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 1.28M| }
416| 1.28M|}
igraph_vector_char_capacity:
436| 42.3M|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 42.3M| return v->stor_end - v->stor_begin;
438| 42.3M|}
igraph_vector_char_reserve:
468| 1.44M|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 1.44M| igraph_int_t current_capacity;
470| 1.44M| BASE *tmp;
------------------
| | 43| 1.44M| #define BASE char
------------------
471| |
472| 1.44M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.44M| do { \
| | 925| 1.44M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.44M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.44M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.44M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.44M]
| | ------------------
------------------
473| 1.44M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.44M| do { \
| | 925| 1.44M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.44M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.44M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.44M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.44M]
| | ------------------
------------------
474| 1.44M| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 1.44M| do { \
| | 925| 1.44M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.44M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.44M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.44M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.44M]
| | ------------------
------------------
475| |
476| 1.44M| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 178| 1.44M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 1.44M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 1.44M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
477| |
478| 1.44M| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 880k, False: 564k]
------------------
479| 880k| return IGRAPH_SUCCESS;
480| 880k| }
481| |
482| 564k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 564k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 1.12M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 564k, False: 0]
| | | | | Branch (31:24): [True: 564k, False: 0]
| | | | | Branch (31:66): [True: 564k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 564k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 564k| do { \
| | 710| 564k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 564k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 564k]
| | | | ------------------
| | ------------------
| | 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| 564k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 564k]
| | ------------------
------------------
484| |
485| 564k| v->end = tmp + (v->end - v->stor_begin);
486| 564k| v->stor_begin = tmp;
487| 564k| v->stor_end = v->stor_begin + capacity;
488| |
489| 564k| return IGRAPH_SUCCESS;
490| 564k|}
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| 742k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 742k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 742k| do { \
| | 925| 742k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 742k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 742k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 742k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 742k]
| | ------------------
------------------
544| 742k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 742k| do { \
| | 925| 742k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 742k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 742k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 742k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 742k]
| | ------------------
------------------
545| 742k| v->end = v->stor_begin;
546| 742k|}
igraph_vector_char_push_back:
573| 1.19M|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 1.19M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.19M| do { \
| | 925| 1.19M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.19M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.19M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.19M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.19M]
| | ------------------
------------------
575| 1.19M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.19M| do { \
| | 925| 1.19M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.19M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.19M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.19M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.19M]
| | ------------------
------------------
576| |
577| 1.19M| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 542k, False: 650k]
------------------
578| | /* full, allocate more storage */
579| 542k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 178| 542k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 542k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 542k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
580| 542k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 542k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 542k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 542k, False: 0]
------------------
581| 542k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 542k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 542k]
------------------
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| 542k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 542k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 542k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 542k| do { \
| | 657| 542k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 542k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 542k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 542k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 542k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 542k]
| | ------------------
------------------
588| 542k| }
589| |
590| 1.19M| *(v->end) = e;
591| 1.19M| v->end += 1;
592| |
593| 1.19M| return IGRAPH_SUCCESS;
594| 1.19M|}
igraph_vector_char_resize:
1264| 891k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 891k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 891k| do { \
| | 925| 891k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 891k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 891k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 891k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 891k]
| | ------------------
------------------
1266| 891k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 891k| do { \
| | 925| 891k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 891k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 891k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 891k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 891k]
| | ------------------
------------------
1267| 891k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 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]
| | ------------------
------------------
1268| 891k| v->end = v->stor_begin + new_size;
1269| 891k| return IGRAPH_SUCCESS;
1270| 891k|}
igraph_vector_char_append:
2427| 40.9M| const TYPE(igraph_vector) *from) {
2428| 40.9M| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 40.9M| do { \
| | 925| 40.9M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 40.9M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 40.9M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 40.9M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 40.9M]
| | ------------------
------------------
2429| 40.9M| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 40.9M| do { \
| | 925| 40.9M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 40.9M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 40.9M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 40.9M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 40.9M]
| | ------------------
------------------
2430| |
2431| 40.9M| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 178| 40.9M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 40.9M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 40.9M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2432| 40.9M| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 178| 40.9M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 40.9M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 40.9M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2433| 40.9M| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 178| 40.9M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 40.9M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 40.9M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2434| 40.9M| igraph_int_t new_to_size;
2435| |
2436| 40.9M| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 40.9M| do { \
| | 48| 40.9M| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 40.9M| igraph_int_t _safe_sum; \
| | 50| 40.9M| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 40.9M]
| | ------------------
| | 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.9M| *(res) = _safe_sum; \
| | 54| 40.9M| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 40.9M]
| | ------------------
------------------
2437| |
2438| 40.9M| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 11.0k, False: 40.9M]
------------------
2439| 11.0k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 11.0k|# 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| 11.0k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 11.0k, False: 0]
------------------
2440| 11.0k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 3.49k, False: 7.51k]
------------------
2441| 3.49k| new_to_capacity = new_to_size;
2442| 3.49k| }
2443| 11.0k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 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]
| | ------------------
------------------
2444| 11.0k| }
2445| |
2446| 40.9M| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 40.9M| sizeof(BASE) * from_size);
2448| 40.9M| to->end = to->stor_begin + new_to_size;
2449| |
2450| 40.9M| return IGRAPH_SUCCESS;
2451| 40.9M|}
igraph_vector_bool_init:
134| 16.3k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 16.3k| igraph_int_t alloc_size;
136| 16.3k| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 16.3k| do { \
| | 925| 16.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.3k]
| | ------------------
------------------
137| 16.3k| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 7.23k, False: 9.09k]
------------------
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| 16.3k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 16.3k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 32.6k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 16.3k, False: 0]
| | | | | Branch (31:24): [True: 16.3k, False: 0]
| | | | | Branch (31:66): [True: 16.3k, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 16.3k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 16.3k| do { \
| | 710| 16.3k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 16.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.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| 16.3k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 16.3k]
| | ------------------
------------------
145| 16.3k| v->stor_end = v->stor_begin + alloc_size;
146| 16.3k| v->end = v->stor_begin + size;
147| |
148| 16.3k| return IGRAPH_SUCCESS;
149| 16.3k|}
igraph_vector_bool_destroy:
408| 16.3k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 16.3k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 16.3k| do { \
| | 925| 16.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.3k]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 16.3k| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 16.3k, False: 0]
------------------
413| 16.3k| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 16.3k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 16.3k| }
416| 16.3k|}
igraph_vector_bool_capacity:
436| 49.1k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 49.1k| return v->stor_end - v->stor_begin;
438| 49.1k|}
igraph_vector_bool_reserve:
468| 46.7k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 46.7k| igraph_int_t current_capacity;
470| 46.7k| BASE *tmp;
------------------
| | 53| 46.7k| #define BASE igraph_bool_t
------------------
471| |
472| 46.7k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 46.7k| do { \
| | 925| 46.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 46.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 46.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 46.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 46.7k]
| | ------------------
------------------
473| 46.7k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 46.7k| do { \
| | 925| 46.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 46.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 46.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 46.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 46.7k]
| | ------------------
------------------
474| 46.7k| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 46.7k| do { \
| | 925| 46.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 46.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 46.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 46.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 46.7k]
| | ------------------
------------------
475| |
476| 46.7k| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 175| 46.7k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 46.7k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
477| |
478| 46.7k| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 35.1k, False: 11.6k]
------------------
479| 35.1k| return IGRAPH_SUCCESS;
480| 35.1k| }
481| |
482| 11.6k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 11.6k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 23.2k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 11.6k, False: 0]
| | | | | Branch (31:24): [True: 11.6k, False: 0]
| | | | | Branch (31:66): [True: 11.6k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 11.6k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 11.6k| do { \
| | 710| 11.6k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 11.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.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| 11.6k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 11.6k]
| | ------------------
------------------
484| |
485| 11.6k| v->end = tmp + (v->end - v->stor_begin);
486| 11.6k| v->stor_begin = tmp;
487| 11.6k| v->stor_end = v->stor_begin + capacity;
488| |
489| 11.6k| return IGRAPH_SUCCESS;
490| 11.6k|}
igraph_vector_bool_size:
522| 67.6k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 67.6k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 67.6k| do { \
| | 925| 67.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 67.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 67.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 67.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 67.6k]
| | ------------------
------------------
524| 67.6k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 67.6k| do { \
| | 925| 67.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 67.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 67.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 67.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 67.6k]
| | ------------------
------------------
525| 67.6k| return v->end - v->stor_begin;
526| 67.6k|}
igraph_vector_bool_clear:
542| 32.3k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) {
543| 32.3k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 32.3k| do { \
| | 925| 32.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 32.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 32.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 32.3k]
| | ------------------
------------------
544| 32.3k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 32.3k| do { \
| | 925| 32.3k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 32.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.3k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 32.3k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 32.3k]
| | ------------------
------------------
545| 32.3k| v->end = v->stor_begin;
546| 32.3k|}
igraph_vector_bool_push_back:
573| 447|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 447| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 447| do { \
| | 925| 447| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 447| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 447]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 447| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 447]
| | ------------------
------------------
575| 447| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 447| do { \
| | 925| 447| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 447| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 447]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 447| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 447]
| | ------------------
------------------
576| |
577| 447| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 0, False: 447]
------------------
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| 447| *(v->end) = e;
591| 447| v->end += 1;
592| |
593| 447| return IGRAPH_SUCCESS;
594| 447|}
igraph_vector_bool_resize:
1264| 45.2k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 45.2k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 45.2k| do { \
| | 925| 45.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 45.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 45.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 45.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 45.2k]
| | ------------------
------------------
1266| 45.2k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 45.2k| do { \
| | 925| 45.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 45.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 45.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 45.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 45.2k]
| | ------------------
------------------
1267| 45.2k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 45.2k| do { \
| | 657| 45.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 45.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 45.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 45.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| 45.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 45.2k]
| | ------------------
------------------
1268| 45.2k| v->end = v->stor_begin + new_size;
1269| 45.2k| return IGRAPH_SUCCESS;
1270| 45.2k|}
igraph_vector_bool_append:
2427| 2.38k| const TYPE(igraph_vector) *from) {
2428| 2.38k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 2.38k| do { \
| | 925| 2.38k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.38k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.38k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.38k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.38k]
| | ------------------
------------------
2429| 2.38k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 2.38k| do { \
| | 925| 2.38k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.38k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.38k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.38k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.38k]
| | ------------------
------------------
2430| |
2431| 2.38k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 175| 2.38k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 2.38k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2432| 2.38k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 175| 2.38k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 2.38k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2433| 2.38k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 175| 2.38k| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 2.38k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2434| 2.38k| igraph_int_t new_to_size;
2435| |
2436| 2.38k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 2.38k| do { \
| | 48| 2.38k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 2.38k| igraph_int_t _safe_sum; \
| | 50| 2.38k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 2.38k]
| | ------------------
| | 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.38k| *(res) = _safe_sum; \
| | 54| 2.38k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 2.38k]
| | ------------------
------------------
2437| |
2438| 2.38k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 1.51k, False: 868]
------------------
2439| 1.51k| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 1.51k|# 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.51k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (2439:40): [True: 1.51k, False: 0]
------------------
2440| 1.51k| if (new_to_capacity < new_to_size) {
------------------
| Branch (2440:13): [True: 1.30k, False: 209]
------------------
2441| 1.30k| new_to_capacity = new_to_size;
2442| 1.30k| }
2443| 1.51k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity));
------------------
| | 656| 1.51k| do { \
| | 657| 1.51k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.51k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.51k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.51k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.51k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.51k]
| | ------------------
------------------
2444| 1.51k| }
2445| |
2446| 2.38k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 2.38k| sizeof(BASE) * from_size);
2448| 2.38k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 2.38k| return IGRAPH_SUCCESS;
2451| 2.38k|}
igraph_vector_bool_update:
2524| 294| const TYPE(igraph_vector) *from) {
2525| 294| igraph_int_t n = FUNCTION(igraph_vector, size)(from);
------------------
| | 175| 294| #define FUNCTION(a,c) CONCAT3x(a,bool,c)
| | ------------------
| | | | 21| 294|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | ------------------
------------------
2526| 294| IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, n));
------------------
| | 656| 294| do { \
| | 657| 294| igraph_error_t igraph_i_ret = (expr); \
| | 658| 294| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 294| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 294]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 294| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 294]
| | ------------------
------------------
2527| 294| memcpy(to->stor_begin, from->stor_begin, sizeof(BASE)*n);
2528| 294| return IGRAPH_SUCCESS;
2529| 294|}
igraph_vector_int_init:
134| 1.74M|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) {
135| 1.74M| igraph_int_t alloc_size;
136| 1.74M| IGRAPH_ASSERT(size >= 0);
------------------
| | 924| 1.74M| do { \
| | 925| 1.74M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.74M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.74M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.74M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.74M]
| | ------------------
------------------
137| 1.74M| alloc_size = size > 0 ? size : 1;
------------------
| Branch (137:18): [True: 1.38M, False: 365k]
------------------
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.74M| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
------------------
| | 33| 1.74M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 3.49M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 1.74M, False: 0]
| | | | | Branch (31:24): [True: 1.74M, False: 0]
| | | | | Branch (31:66): [True: 1.74M, False: 0]
| | | | ------------------
| | ------------------
------------------
144| 1.74M| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector.");
------------------
| | 709| 1.74M| do { \
| | 710| 1.74M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.74M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.74M]
| | | | ------------------
| | ------------------
| | 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.74M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.74M]
| | ------------------
------------------
145| 1.74M| v->stor_end = v->stor_begin + alloc_size;
146| 1.74M| v->end = v->stor_begin + size;
147| |
148| 1.74M| return IGRAPH_SUCCESS;
149| 1.74M|}
igraph_vector_int_destroy:
408| 1.74M|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) {
409| 1.74M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.74M| do { \
| | 925| 1.74M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.74M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.74M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.74M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.74M]
| | ------------------
------------------
410| | /* vector_init() will leave stor_begin set to NULL when it fails.
411| | * We handle these cases gracefully. */
412| 1.74M| if (v->stor_begin != NULL) {
------------------
| Branch (412:9): [True: 1.74M, False: 0]
------------------
413| 1.74M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 1.74M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
414| | v->stor_begin = NULL;
415| 1.74M| }
416| 1.74M|}
igraph_vector_int_capacity:
436| 1.08M|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) {
437| 1.08M| return v->stor_end - v->stor_begin;
438| 1.08M|}
igraph_vector_int_reserve:
468| 1.08M|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) {
469| 1.08M| igraph_int_t current_capacity;
470| 1.08M| BASE *tmp;
------------------
| | 66| 1.08M| #define BASE igraph_int_t
------------------
471| |
472| 1.08M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.08M| do { \
| | 925| 1.08M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.08M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.08M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.08M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.08M]
| | ------------------
------------------
473| 1.08M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.08M| do { \
| | 925| 1.08M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.08M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.08M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.08M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.08M]
| | ------------------
------------------
474| 1.08M| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 1.08M| do { \
| | 925| 1.08M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.08M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.08M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.08M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.08M]
| | ------------------
------------------
475| |
476| 1.08M| current_capacity = FUNCTION(igraph_vector, capacity)(v);
------------------
| | 178| 1.08M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 1.08M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 1.08M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
477| |
478| 1.08M| if (capacity <= current_capacity) {
------------------
| Branch (478:9): [True: 346k, False: 739k]
------------------
479| 346k| return IGRAPH_SUCCESS;
480| 346k| }
481| |
482| 739k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE);
------------------
| | 35| 739k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 1.47M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 739k, False: 0]
| | | | | Branch (31:24): [True: 739k, False: 0]
| | | | | Branch (31:66): [True: 739k, False: 0]
| | | | ------------------
| | ------------------
------------------
483| 739k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector.");
------------------
| | 709| 739k| do { \
| | 710| 739k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 739k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 739k]
| | | | ------------------
| | ------------------
| | 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| 739k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 739k]
| | ------------------
------------------
484| |
485| 739k| v->end = tmp + (v->end - v->stor_begin);
486| 739k| v->stor_begin = tmp;
487| 739k| v->stor_end = v->stor_begin + capacity;
488| |
489| 739k| return IGRAPH_SUCCESS;
490| 739k|}
igraph_vector_int_empty:
503| 384k|igraph_bool_t FUNCTION(igraph_vector, empty)(const TYPE(igraph_vector) *v) {
504| 384k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 384k| do { \
| | 925| 384k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 384k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 384k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 384k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 384k]
| | ------------------
------------------
505| 384k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 384k| do { \
| | 925| 384k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 384k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 384k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 384k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 384k]
| | ------------------
------------------
506| 384k| return v->stor_begin == v->end;
507| 384k|}
igraph_vector_int_size:
522| 6.27M|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) {
523| 6.27M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 6.27M| do { \
| | 925| 6.27M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.27M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.27M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.27M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.27M]
| | ------------------
------------------
524| 6.27M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 6.27M| do { \
| | 925| 6.27M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.27M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.27M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.27M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.27M]
| | ------------------
------------------
525| 6.27M| return v->end - v->stor_begin;
526| 6.27M|}
igraph_vector_int_push_back:
573| 6.89M|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) {
574| 6.89M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 6.89M| do { \
| | 925| 6.89M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.89M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.89M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.89M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.89M]
| | ------------------
------------------
575| 6.89M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 6.89M| do { \
| | 925| 6.89M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 6.89M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.89M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 6.89M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 6.89M]
| | ------------------
------------------
576| |
577| 6.89M| if (v->stor_end == v->end) {
------------------
| Branch (577:9): [True: 638k, False: 6.25M]
------------------
578| | /* full, allocate more storage */
579| 638k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v);
------------------
| | 178| 638k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 638k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 638k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
580| 638k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 638k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX;
------------------
| | 72| 638k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (580:33): [True: 638k, False: 0]
------------------
581| 638k| if (old_size == IGRAPH_INTEGER_MAX) {
------------------
| | 72| 638k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
| Branch (581:13): [True: 0, False: 638k]
------------------
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| 638k| if (new_size == 0) {
------------------
| Branch (584:13): [True: 0, False: 638k]
------------------
585| 0| new_size = 1;
586| 0| }
587| 638k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 638k| do { \
| | 657| 638k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 638k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 638k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 638k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 638k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 638k]
| | ------------------
------------------
588| 638k| }
589| |
590| 6.89M| *(v->end) = e;
591| 6.89M| v->end += 1;
592| |
593| 6.89M| return IGRAPH_SUCCESS;
594| 6.89M|}
igraph_vector_int_null:
725| 83.6k|void FUNCTION(igraph_vector, null)(TYPE(igraph_vector) *v) {
726| 83.6k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 83.6k| do { \
| | 925| 83.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 83.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 83.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 83.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 83.6k]
| | ------------------
------------------
727| 83.6k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 83.6k| do { \
| | 925| 83.6k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 83.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 83.6k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 83.6k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 83.6k]
| | ------------------
------------------
728| 83.6k| if (FUNCTION(igraph_vector, size)(v) > 0) {
------------------
| | 178| 83.6k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 83.6k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 83.6k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
| Branch (728:9): [True: 72.0k, False: 11.5k]
------------------
729| 72.0k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v));
------------------
| | 178| 72.0k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 72.0k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 72.0k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
730| 72.0k| }
731| 83.6k|}
igraph_vector_int_pop_back:
838| 378k|BASE FUNCTION(igraph_vector, pop_back)(TYPE(igraph_vector) *v) {
839| 378k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 378k| do { \
| | 925| 378k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 378k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 378k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 378k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 378k]
| | ------------------
------------------
840| 378k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 378k| do { \
| | 925| 378k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 378k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 378k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 378k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 378k]
| | ------------------
------------------
841| 378k| IGRAPH_ASSERT(v->end != NULL);
------------------
| | 924| 378k| do { \
| | 925| 378k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 378k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 378k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 378k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 378k]
| | ------------------
------------------
842| 378k| IGRAPH_ASSERT(v->end != v->stor_begin);
------------------
| | 924| 378k| do { \
| | 925| 378k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 378k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 378k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 378k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 378k]
| | ------------------
------------------
843| |
844| 378k| (v->end)--;
845| |
846| 378k| return *(v->end);
847| 378k|}
igraph_vector_int_resize:
1264| 309k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) {
1265| 309k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 309k| do { \
| | 925| 309k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 309k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 309k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 309k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 309k]
| | ------------------
------------------
1266| 309k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 309k| do { \
| | 925| 309k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 309k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 309k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 309k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 309k]
| | ------------------
------------------
1267| 309k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
------------------
| | 656| 309k| do { \
| | 657| 309k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 309k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 309k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 309k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 309k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 309k]
| | ------------------
------------------
1268| 309k| v->end = v->stor_begin + new_size;
1269| 309k| return IGRAPH_SUCCESS;
1270| 309k|}
igraph_vector_int_max:
1327| 2.51k|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector) *v) {
1328| 2.51k| BASE max;
------------------
| | 66| 2.51k| #define BASE igraph_int_t
------------------
1329| 2.51k| BASE *ptr;
------------------
| | 66| 2.51k| #define BASE igraph_int_t
------------------
1330| 2.51k| IGRAPH_ASSERT(!FUNCTION(igraph_vector, empty)(v));
------------------
| | 924| 2.51k| do { \
| | 925| 2.51k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.51k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.51k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.51k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.51k]
| | ------------------
------------------
1331| 2.51k| max = *(v->stor_begin);
1332| |#if defined(BASE_IGRAPH_REAL)
1333| | if (isnan(max)) { return max; }; /* Result is NaN */
1334| |#endif
1335| 2.51k| ptr = v->stor_begin + 1;
1336| 558k| while (ptr < v->end) {
------------------
| Branch (1336:12): [True: 555k, False: 2.51k]
------------------
1337| 555k| if ((*ptr) > max) {
------------------
| Branch (1337:13): [True: 23.5k, False: 532k]
------------------
1338| 23.5k| max = *ptr;
1339| 23.5k| }
1340| |#if defined(BASE_IGRAPH_REAL)
1341| | else if (isnan(*ptr))
1342| | return *ptr; /* Result is NaN */
1343| |#endif
1344| 555k| ptr++;
1345| 555k| }
1346| 2.51k| return max;
1347| 2.51k|}
igraph_vector_int_isininterval:
1832| 17.5k| BASE high) {
1833| 17.5k| BASE *ptr;
------------------
| | 66| 17.5k| #define BASE igraph_int_t
------------------
1834| 17.5k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 17.5k| do { \
| | 925| 17.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 17.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 17.5k]
| | ------------------
------------------
1835| 17.5k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 17.5k| do { \
| | 925| 17.5k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.5k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 17.5k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 17.5k]
| | ------------------
------------------
1836| 2.81M| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (1836:31): [True: 2.79M, False: 17.5k]
------------------
1837| | /* Note that the following is not equivalent to *ptr < low || *ptr > high
1838| | * when *ptr is NaN! */
1839| 2.79M| if (!(*ptr >= low && *ptr <= high)) {
------------------
| Branch (1839:15): [True: 2.79M, False: 0]
| Branch (1839:30): [True: 2.79M, False: 0]
------------------
1840| 0| return 0;
1841| 0| }
1842| 2.79M| }
1843| 17.5k| return 1;
1844| 17.5k|}
igraph_vector_int_append:
2427| 2.20k| const TYPE(igraph_vector) *from) {
2428| 2.20k| IGRAPH_ASSERT(to != NULL);
------------------
| | 924| 2.20k| do { \
| | 925| 2.20k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.20k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.20k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.20k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.20k]
| | ------------------
------------------
2429| 2.20k| IGRAPH_ASSERT(to->stor_begin != NULL);
------------------
| | 924| 2.20k| do { \
| | 925| 2.20k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.20k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.20k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.20k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.20k]
| | ------------------
------------------
2430| |
2431| 2.20k| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to);
------------------
| | 178| 2.20k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.20k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.20k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2432| 2.20k| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from);
------------------
| | 178| 2.20k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.20k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.20k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2433| 2.20k| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to);
------------------
| | 178| 2.20k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
| | ------------------
| | | | 22| 2.20k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
| | | | ------------------
| | | | | | 21| 2.20k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
| | | | ------------------
| | ------------------
------------------
2434| 2.20k| igraph_int_t new_to_size;
2435| |
2436| 2.20k| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size);
------------------
| | 47| 2.20k| do { \
| | 48| 2.20k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 2.20k| igraph_int_t _safe_sum; \
| | 50| 2.20k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 2.20k]
| | ------------------
| | 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.20k| *(res) = _safe_sum; \
| | 54| 2.20k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 2.20k]
| | ------------------
------------------
2437| |
2438| 2.20k| if (to_capacity < new_to_size) {
------------------
| Branch (2438:9): [True: 0, False: 2.20k]
------------------
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.20k| memcpy(to->stor_begin + to_size, from->stor_begin,
2447| 2.20k| sizeof(BASE) * from_size);
2448| 2.20k| to->end = to->stor_begin + new_to_size;
2449| |
2450| 2.20k| return IGRAPH_SUCCESS;
2451| 2.20k|}
vector.c:igraph_vector_sort_cmp:
924| 2.00k|static int FUNCTION(igraph_vector, sort_cmp)(const void *a, const void *b) {
925| 2.00k| const BASE *da = (const BASE *) a;
926| 2.00k| const BASE *db = (const BASE *) b;
927| |
928| 2.00k| return (*da > *db) - (*da < *db);
929| 2.00k|}
igraph_vector_ptr_init:
86| 2.73M|igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_int_t size) {
87| 2.73M| igraph_int_t alloc_size = size > 0 ? size : 1;
------------------
| Branch (87:31): [True: 2.53M, False: 195k]
------------------
88| 2.73M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 2.73M| do { \
| | 925| 2.73M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.73M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.73M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.73M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.73M]
| | ------------------
------------------
89| 2.73M| if (size < 0) {
------------------
| Branch (89:9): [True: 0, False: 2.73M]
------------------
90| 0| size = 0;
91| 0| }
92| 2.73M| v->stor_begin = IGRAPH_CALLOC(alloc_size, void*);
------------------
| | 33| 2.73M|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 5.46M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 2.73M, False: 0]
| | | | | Branch (31:24): [True: 2.73M, False: 0]
| | | | | Branch (31:66): [True: 2.73M, False: 0]
| | | | ------------------
| | ------------------
------------------
93| 2.73M| if (v->stor_begin == 0) {
------------------
| Branch (93:9): [True: 0, False: 2.73M]
------------------
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| 2.73M| v->stor_end = v->stor_begin + alloc_size;
97| 2.73M| v->end = v->stor_begin + size;
98| 2.73M| v->item_destructor = 0;
99| |
100| 2.73M| return IGRAPH_SUCCESS;
101| 2.73M|}
igraph_vector_ptr_destroy:
132| 2.73M|void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) {
133| 2.73M| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 2.73M| do { \
| | 925| 2.73M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.73M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.73M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.73M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.73M]
| | ------------------
------------------
134| 2.73M| if (v->stor_begin != 0) {
------------------
| Branch (134:9): [True: 2.73M, False: 0]
------------------
135| 2.73M| IGRAPH_FREE(v->stor_begin);
------------------
| | 36| 2.73M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
136| | v->stor_begin = NULL;
137| 2.73M| }
138| 2.73M|}
igraph_vector_ptr_free_all:
170| 74.7k|void igraph_vector_ptr_free_all(igraph_vector_ptr_t* v) {
171| 74.7k| void **ptr;
172| 74.7k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 74.7k| do { \
| | 925| 74.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 74.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 74.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 74.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 74.7k]
| | ------------------
------------------
173| 74.7k| IGRAPH_ASSERT(v->stor_begin != 0);
------------------
| | 924| 74.7k| do { \
| | 925| 74.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 74.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 74.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 74.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 74.7k]
| | ------------------
------------------
174| |
175| 74.7k| igraph_i_vector_ptr_call_item_destructor_all(v);
176| 89.4k| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (176:31): [True: 14.7k, False: 74.7k]
------------------
177| | IGRAPH_FREE(*ptr);
------------------
| | 36| 14.7k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
178| 14.7k| }
179| 74.7k|}
igraph_vector_ptr_destroy_all:
199| 74.7k|void igraph_vector_ptr_destroy_all(igraph_vector_ptr_t* v) {
200| 74.7k| IGRAPH_ASSERT(v != 0);
------------------
| | 924| 74.7k| do { \
| | 925| 74.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 74.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 74.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 74.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 74.7k]
| | ------------------
------------------
201| 74.7k| IGRAPH_ASSERT(v->stor_begin != 0);
------------------
| | 924| 74.7k| do { \
| | 925| 74.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 74.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 74.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 74.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 74.7k]
| | ------------------
------------------
202| 74.7k| igraph_vector_ptr_free_all(v);
203| 74.7k| igraph_vector_ptr_set_item_destructor(v, 0);
204| 74.7k| igraph_vector_ptr_destroy(v);
205| 74.7k|}
igraph_vector_ptr_reserve:
215| 1.14M|igraph_error_t igraph_vector_ptr_reserve(igraph_vector_ptr_t* v, igraph_int_t capacity) {
216| 1.14M| igraph_int_t actual_size = igraph_vector_ptr_size(v);
217| 1.14M| void **tmp;
218| 1.14M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 1.14M| do { \
| | 925| 1.14M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.14M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.14M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.14M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.14M]
| | ------------------
------------------
219| 1.14M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 1.14M| do { \
| | 925| 1.14M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.14M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.14M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.14M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.14M]
| | ------------------
------------------
220| 1.14M| IGRAPH_ASSERT(capacity >= 0);
------------------
| | 924| 1.14M| do { \
| | 925| 1.14M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 1.14M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.14M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 1.14M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 1.14M]
| | ------------------
------------------
221| |
222| 1.14M| if (capacity <= igraph_vector_ptr_size(v)) {
------------------
| Branch (222:9): [True: 0, False: 1.14M]
------------------
223| 0| return IGRAPH_SUCCESS;
224| 0| }
225| |
226| 1.14M| tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) capacity, void*);
------------------
| | 35| 1.14M|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1)))
| | ------------------
| | | | 31| 2.28M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 1.14M, False: 0]
| | | | | Branch (31:24): [True: 1.14M, False: 0]
| | | | | Branch (31:66): [True: 1.14M, False: 0]
| | | | ------------------
| | ------------------
------------------
227| 1.14M| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for pointer vector.");
------------------
| | 709| 1.14M| do { \
| | 710| 1.14M| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.14M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.14M]
| | | | ------------------
| | ------------------
| | 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.14M| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.14M]
| | ------------------
------------------
228| |
229| 1.14M| v->stor_begin = tmp;
230| 1.14M| v->stor_end = v->stor_begin + capacity;
231| 1.14M| v->end = v->stor_begin + actual_size;
232| |
233| 1.14M| return IGRAPH_SUCCESS;
234| 1.14M|}
igraph_vector_ptr_size:
291| 7.46M|igraph_int_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v) {
292| 7.46M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 7.46M| do { \
| | 925| 7.46M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 7.46M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.46M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 7.46M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 7.46M]
| | ------------------
------------------
293| 7.46M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 7.46M| do { \
| | 925| 7.46M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 7.46M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.46M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 7.46M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 7.46M]
| | ------------------
------------------
294| 7.46M| return v->end - v->stor_begin;
295| 7.46M|}
igraph_vector_ptr_push_back:
360| 2.03M|igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) {
361| 2.03M| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 2.03M| do { \
| | 925| 2.03M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.03M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.03M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.03M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.03M]
| | ------------------
------------------
362| 2.03M| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 2.03M| do { \
| | 925| 2.03M| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 2.03M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.03M]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 2.03M| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 2.03M]
| | ------------------
------------------
363| |
364| | /* full, allocate more storage */
365| 2.03M| if (v->stor_end == v->end) {
------------------
| Branch (365:9): [True: 1.14M, False: 891k]
------------------
366| 1.14M| igraph_int_t new_size = igraph_vector_ptr_size(v) * 2;
367| 1.14M| if (new_size == 0) {
------------------
| Branch (367:13): [True: 0, False: 1.14M]
------------------
368| 0| new_size = 1;
369| 0| }
370| 1.14M| IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size));
------------------
| | 656| 1.14M| do { \
| | 657| 1.14M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.14M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.14M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.14M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.14M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.14M]
| | ------------------
------------------
371| 1.14M| }
372| |
373| 2.03M| *(v->end) = e;
374| 2.03M| v->end += 1;
375| |
376| 2.03M| return IGRAPH_SUCCESS;
377| 2.03M|}
igraph_vector_ptr_get:
439| 16.8k|void *igraph_vector_ptr_get(const igraph_vector_ptr_t* v, igraph_int_t pos) {
440| 16.8k| IGRAPH_ASSERT(v != NULL);
------------------
| | 924| 16.8k| do { \
| | 925| 16.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.8k]
| | ------------------
------------------
441| 16.8k| IGRAPH_ASSERT(v->stor_begin != NULL);
------------------
| | 924| 16.8k| do { \
| | 925| 16.8k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 16.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16.8k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 16.8k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 16.8k]
| | ------------------
------------------
442| 16.8k| return *(v->stor_begin + pos);
443| 16.8k|}
igraph_vector_ptr_set_item_destructor:
669| 149k| igraph_vector_ptr_t *v, igraph_finally_func_t *func) {
670| 149k| igraph_finally_func_t* result = v->item_destructor;
671| |
672| 149k| v->item_destructor = func;
673| |
674| 149k| return result;
675| 149k|}
vector_ptr.c:igraph_i_vector_ptr_call_item_destructor_all:
140| 74.7k|static void igraph_i_vector_ptr_call_item_destructor_all(igraph_vector_ptr_t* v) {
141| 74.7k| void **ptr;
142| |
143| 74.7k| if (v->item_destructor != 0) {
------------------
| Branch (143:9): [True: 74.7k, False: 0]
------------------
144| 89.4k| for (ptr = v->stor_begin; ptr < v->end; ptr++) {
------------------
| Branch (144:35): [True: 14.7k, False: 74.7k]
------------------
145| 14.7k| if (*ptr != 0) {
------------------
| Branch (145:17): [True: 14.7k, False: 0]
------------------
146| 14.7k| v->item_destructor(*ptr);
147| 14.7k| }
148| 14.7k| }
149| 74.7k| }
150| 74.7k|}
igraph_attribute_record_init:
126| 66.0k|) {
127| 66.0k| attr->name = NULL;
128| 66.0k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
129| 66.0k| attr->value.as_raw = NULL;
130| 66.0k| attr->default_value.string = NULL;
131| |
132| 66.0k| IGRAPH_CHECK(igraph_attribute_record_set_name(attr, name));
------------------
| | 656| 66.0k| do { \
| | 657| 66.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 66.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 66.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.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| 66.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 66.0k]
| | ------------------
------------------
133| 66.0k| IGRAPH_FINALLY(igraph_free, attr->name);
------------------
| | 603| 66.0k| do { \
| | 604| 66.0k| /* the following branch makes the compiler check the compatibility of \
| | 605| 66.0k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 66.0k| * incorrect destructor function with the pointer */ \
| | 607| 66.0k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 66.0k]
| | ------------------
| | 608| 66.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 66.0k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 66.0k]
| | ------------------
------------------
134| 66.0k| IGRAPH_CHECK(igraph_attribute_record_set_type(attr, type));
------------------
| | 656| 66.0k| do { \
| | 657| 66.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 66.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 66.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.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| 66.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 66.0k]
| | ------------------
------------------
135| 66.0k| IGRAPH_FINALLY_CLEAN(1);
136| |
137| 66.0k| return IGRAPH_SUCCESS;
138| 66.0k|}
igraph_attribute_record_init_copy:
159| 2.44k|) {
160| 2.44k| IGRAPH_CHECK(igraph_attribute_record_init(to, from->name, from->type));
------------------
| | 656| 2.44k| do { \
| | 657| 2.44k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.44k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.44k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.44k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.44k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.44k]
| | ------------------
------------------
161| |
162| 2.44k| switch (from->type) {
163| 314| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (163:9): [True: 314, False: 2.12k]
------------------
164| 314| IGRAPH_CHECK(igraph_vector_update(to->value.as_vector, from->value.as_vector));
------------------
| | 656| 314| do { \
| | 657| 314| igraph_error_t igraph_i_ret = (expr); \
| | 658| 314| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 314]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 314| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 314]
| | ------------------
------------------
165| 314| break;
166| |
167| 1.83k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (167:9): [True: 1.83k, False: 608]
------------------
168| 1.83k| IGRAPH_CHECK(igraph_strvector_update(to->value.as_strvector, from->value.as_strvector));
------------------
| | 656| 1.83k| do { \
| | 657| 1.83k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.83k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.83k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.83k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.83k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.83k]
| | ------------------
------------------
169| 1.83k| break;
170| |
171| 1.83k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (171:9): [True: 294, False: 2.14k]
------------------
172| 294| IGRAPH_CHECK(igraph_vector_bool_update(to->value.as_vector_bool, from->value.as_vector_bool));
------------------
| | 656| 294| do { \
| | 657| 294| igraph_error_t igraph_i_ret = (expr); \
| | 658| 294| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 294| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 294]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 294| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 294]
| | ------------------
------------------
173| 294| break;
174| |
175| 294| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (175:9): [True: 0, False: 2.44k]
------------------
176| 0| break;
177| |
178| 0| default:
------------------
| Branch (178:9): [True: 0, False: 2.44k]
------------------
179| 0| break;
180| 2.44k| }
181| |
182| 2.44k| return IGRAPH_SUCCESS;
183| 2.44k|}
igraph_attribute_record_destroy:
241| 69.5k|void igraph_attribute_record_destroy(igraph_attribute_record_t *attr) {
242| 69.5k| igraph_i_attribute_record_destroy_values(attr);
243| |
244| 69.5k| if (attr->name) {
------------------
| Branch (244:9): [True: 66.0k, False: 3.50k]
------------------
245| 66.0k| igraph_free(attr->name);
246| | attr->name = NULL;
247| 66.0k| }
248| 69.5k|}
igraph_attribute_record_check_type:
264| 1.41M|) {
265| 1.41M| if (type != attr->type) {
------------------
| Branch (265:9): [True: 1, False: 1.41M]
------------------
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.41M| return IGRAPH_SUCCESS;
286| 1.41M|}
igraph_attribute_record_size:
295| 428k|igraph_int_t igraph_attribute_record_size(const igraph_attribute_record_t *attr) {
296| 428k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 428k| do { \
| | 925| 428k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 428k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 428k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 428k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 428k]
| | ------------------
------------------
297| |
298| 428k| switch (attr->type) {
299| 17.4k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (299:9): [True: 17.4k, False: 411k]
------------------
300| 17.4k| return igraph_vector_size(attr->value.as_vector);
301| |
302| 395k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (302:9): [True: 395k, False: 33.0k]
------------------
303| 395k| return igraph_strvector_size(attr->value.as_strvector);
304| |
305| 15.2k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (305:9): [True: 15.2k, False: 413k]
------------------
306| 15.2k| return igraph_vector_bool_size(attr->value.as_vector_bool);
307| |
308| 342| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (308:9): [True: 342, False: 428k]
------------------
309| 342| return 0;
310| |
311| 0| default:
------------------
| Branch (311:9): [True: 0, False: 428k]
------------------
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| 428k| }
314| 428k|}
igraph_attribute_record_resize:
332| 389k|) {
333| 389k| igraph_int_t i;
334| 389k| igraph_vector_t *vec;
335| 389k| igraph_vector_bool_t *log;
336| 389k| igraph_strvector_t *str;
337| |
338| 389k| IGRAPH_ASSERT(attr != 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]
| | ------------------
------------------
339| |
340| 389k| switch (attr->type) {
341| |
342| 11.2k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (342:9): [True: 11.2k, False: 378k]
------------------
343| 11.2k| vec = attr->value.as_vector;
344| 11.2k| i = igraph_vector_size(vec);
345| 11.2k| IGRAPH_CHECK(igraph_vector_resize(vec, new_size));
------------------
| | 656| 11.2k| do { \
| | 657| 11.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.2k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 11.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.2k]
| | ------------------
------------------
346| 239k| while (i < new_size) {
------------------
| Branch (346:20): [True: 227k, False: 11.2k]
------------------
347| 227k| VECTOR(*vec)[i++] = attr->default_value.numeric;
------------------
| | 60| 227k|#define VECTOR(v) ((v).stor_begin)
------------------
348| 227k| }
349| 11.2k| break;
350| |
351| 13.1k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (351:9): [True: 13.1k, False: 376k]
------------------
352| 13.1k| log = attr->value.as_vector_bool;
353| 13.1k| i = igraph_vector_bool_size(log);
354| 13.1k| IGRAPH_CHECK(igraph_vector_bool_resize(log, 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]
| | ------------------
------------------
355| 34.3k| while (i < new_size) {
------------------
| Branch (355:20): [True: 21.1k, False: 13.1k]
------------------
356| 21.1k| VECTOR(*log)[i++] = attr->default_value.boolean;
------------------
| | 60| 21.1k|#define VECTOR(v) ((v).stor_begin)
------------------
357| 21.1k| }
358| 13.1k| break;
359| |
360| 364k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (360:9): [True: 364k, False: 24.4k]
------------------
361| 364k| str = attr->value.as_strvector;
362| 364k| if (attr->default_value.string == 0 || (*attr->default_value.string == 0)) {
------------------
| Branch (362:17): [True: 364k, False: 789]
| Branch (362:52): [True: 0, False: 789]
------------------
363| 364k| IGRAPH_CHECK(igraph_strvector_resize(str, new_size));
------------------
| | 656| 364k| do { \
| | 657| 364k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 364k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 364k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 364k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 364k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 364k]
| | ------------------
------------------
364| 364k| } else {
365| 789| i = igraph_strvector_size(str);
366| 789| IGRAPH_CHECK(igraph_strvector_resize(str, new_size));
------------------
| | 656| 789| do { \
| | 657| 789| igraph_error_t igraph_i_ret = (expr); \
| | 658| 789| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 789| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 789]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 789| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 789]
| | ------------------
------------------
367| 101k| while (i < new_size) {
------------------
| Branch (367:24): [True: 100k, False: 789]
------------------
368| 100k| IGRAPH_CHECK(igraph_strvector_set(str, i++, attr->default_value.string));
------------------
| | 656| 100k| do { \
| | 657| 100k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 100k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 100k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 100k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 100k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 100k]
| | ------------------
------------------
369| 100k| }
370| 789| }
371| 364k| break;
372| |
373| 364k| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (373:9): [True: 0, False: 389k]
------------------
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: 389k]
------------------
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| 389k| }
380| |
381| 389k| return IGRAPH_SUCCESS;
382| 389k|}
igraph_attribute_record_set_default_numeric:
399| 12.9k|) {
400| 12.9k| if (attr->type != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (400:9): [True: 0, False: 12.9k]
------------------
401| 0| return IGRAPH_EINVAL;
402| 0| }
403| |
404| 12.9k| attr->default_value.numeric = value;
405| 12.9k| return IGRAPH_SUCCESS;
406| 12.9k|}
igraph_attribute_record_set_default_boolean:
423| 1.73k|) {
424| 1.73k| if (attr->type != IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (424:9): [True: 0, False: 1.73k]
------------------
425| 0| return IGRAPH_EINVAL;
426| 0| }
427| |
428| 1.73k| attr->default_value.boolean = value;
429| 1.73k| return IGRAPH_SUCCESS;
430| 1.73k|}
igraph_attribute_record_set_default_string:
449| 1.02k|) {
450| 1.02k| char* copy;
451| |
452| 1.02k| if (attr->type != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (452:9): [True: 0, False: 1.02k]
------------------
453| 0| return IGRAPH_EINVAL;
454| 0| }
455| |
456| 1.02k| if (value && (*value != 0)) {
------------------
| Branch (456:9): [True: 1.02k, False: 0]
| Branch (456:18): [True: 1.02k, False: 0]
------------------
457| 1.02k| copy = strdup(value);
458| 1.02k| IGRAPH_CHECK_OOM(copy, "Insufficient memory to duplicate default value.");
------------------
| | 709| 1.02k| do { \
| | 710| 1.02k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 1.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.02k]
| | | | ------------------
| | ------------------
| | 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.02k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 1.02k]
| | ------------------
------------------
459| 1.02k| } else {
460| 0| copy = NULL;
461| 0| }
462| |
463| 1.02k| if (attr->default_value.string) {
------------------
| Branch (463:9): [True: 220, False: 809]
------------------
464| 220| igraph_free(attr->default_value.string);
465| 220| }
466| 1.02k| attr->default_value.string = copy;
467| |
468| 1.02k| return IGRAPH_SUCCESS;
469| 1.02k|}
igraph_attribute_record_set_name:
483| 107k|) {
484| 107k| char *new_name;
485| |
486| 107k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 107k| do { \
| | 925| 107k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 107k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 107k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 107k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 107k]
| | ------------------
------------------
487| |
488| 107k| if (name != NULL) {
------------------
| Branch (488:9): [True: 66.0k, False: 41.6k]
------------------
489| 66.0k| new_name = strdup(name);
490| 66.0k| IGRAPH_CHECK_OOM(new_name, "Insufficient memory for allocating attribute name.");
------------------
| | 709| 66.0k| do { \
| | 710| 66.0k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 66.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.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| 66.0k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 66.0k]
| | ------------------
------------------
491| 66.0k| } else {
492| 41.6k| new_name = NULL;
493| 41.6k| }
494| |
495| 107k| if (attr->name) {
------------------
| Branch (495:9): [True: 0, False: 107k]
------------------
496| 0| igraph_free(attr->name);
497| 0| }
498| |
499| 107k| attr->name = new_name;
500| |
501| 107k| return IGRAPH_SUCCESS;
502| 107k|}
igraph_attribute_record_set_type:
539| 107k|) {
540| 107k| void *ptr;
541| |
542| 107k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 107k| do { \
| | 925| 107k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 107k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 107k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 107k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 107k]
| | ------------------
------------------
543| |
544| 107k| if (attr->type != type) {
------------------
| Branch (544:9): [True: 65.4k, False: 42.2k]
------------------
545| 65.4k| switch (type) {
546| 12.2k| case IGRAPH_ATTRIBUTE_NUMERIC: {
------------------
| Branch (546:13): [True: 12.2k, False: 53.1k]
------------------
547| 12.2k| igraph_vector_t *vec = IGRAPH_CALLOC(1, igraph_vector_t);
------------------
| | 33| 12.2k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 24.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: 12.2k, Folded]
| | | | ------------------
| | ------------------
------------------
548| 12.2k| IGRAPH_CHECK_OOM(vec, "Insufficient memory for attribute record.");
------------------
| | 709| 12.2k| do { \
| | 710| 12.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 12.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 12.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 12.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 12.2k]
| | ------------------
------------------
549| 12.2k| IGRAPH_FINALLY(igraph_free, vec);
------------------
| | 603| 12.2k| do { \
| | 604| 12.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 12.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 12.2k| * incorrect destructor function with the pointer */ \
| | 607| 12.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 12.2k]
| | ------------------
| | 608| 12.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 12.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 12.2k]
| | ------------------
------------------
550| 12.2k| IGRAPH_VECTOR_INIT_FINALLY(vec, 0);
------------------
| | 104| 12.2k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 12.2k| do { \
| | | | 657| 12.2k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 12.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 12.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 12.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| 12.2k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 12.2k]
| | | | ------------------
| | ------------------
| | 105| 12.2k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 12.2k| do { \
| | | | 604| 12.2k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 12.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 12.2k| * incorrect destructor function with the pointer */ \
| | | | 607| 12.2k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 12.2k]
| | | | ------------------
| | | | 608| 12.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 12.2k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 12.2k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 12.2k]
| | ------------------
------------------
551| 12.2k| ptr = vec;
552| 12.2k| }
553| 0| break;
554| |
555| 47.6k| case IGRAPH_ATTRIBUTE_STRING: {
------------------
| Branch (555:13): [True: 47.6k, False: 17.8k]
------------------
556| 47.6k| igraph_strvector_t *strvec = IGRAPH_CALLOC(1, igraph_strvector_t);
------------------
| | 33| 47.6k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 95.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: 47.6k, Folded]
| | | | ------------------
| | ------------------
------------------
557| 47.6k| IGRAPH_CHECK_OOM(strvec, "Insufficient memory for attribute record.");
------------------
| | 709| 47.6k| do { \
| | 710| 47.6k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 47.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 47.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| 47.6k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 47.6k]
| | ------------------
------------------
558| 47.6k| IGRAPH_FINALLY(igraph_free, strvec);
------------------
| | 603| 47.6k| do { \
| | 604| 47.6k| /* the following branch makes the compiler check the compatibility of \
| | 605| 47.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 47.6k| * incorrect destructor function with the pointer */ \
| | 607| 47.6k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 47.6k]
| | ------------------
| | 608| 47.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 47.6k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 47.6k]
| | ------------------
------------------
559| 47.6k| IGRAPH_STRVECTOR_INIT_FINALLY(strvec, 0);
------------------
| | 62| 47.6k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 47.6k| do { \
| | | | 657| 47.6k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 47.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 47.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 47.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| 47.6k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 47.6k]
| | | | ------------------
| | ------------------
| | 63| 47.6k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 47.6k| do { \
| | | | 604| 47.6k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 47.6k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 47.6k| * incorrect destructor function with the pointer */ \
| | | | 607| 47.6k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 47.6k]
| | | | ------------------
| | | | 608| 47.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 47.6k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 47.6k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 47.6k]
| | ------------------
------------------
560| 47.6k| ptr = strvec;
561| 47.6k| }
562| 0| break;
563| |
564| 5.51k| case IGRAPH_ATTRIBUTE_BOOLEAN: {
------------------
| Branch (564:13): [True: 5.51k, False: 59.9k]
------------------
565| 5.51k| igraph_vector_bool_t *boolvec = IGRAPH_CALLOC(1, igraph_vector_bool_t);
------------------
| | 33| 5.51k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 11.0k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 5.51k, Folded]
| | | | ------------------
| | ------------------
------------------
566| 5.51k| IGRAPH_CHECK_OOM(boolvec, "Insufficient memory for attribute record.");
------------------
| | 709| 5.51k| do { \
| | 710| 5.51k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 5.51k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.51k]
| | | | ------------------
| | ------------------
| | 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| 5.51k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 5.51k]
| | ------------------
------------------
567| 5.51k| IGRAPH_FINALLY(igraph_free, boolvec);
------------------
| | 603| 5.51k| do { \
| | 604| 5.51k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.51k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.51k| * incorrect destructor function with the pointer */ \
| | 607| 5.51k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.51k]
| | ------------------
| | 608| 5.51k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.51k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.51k]
| | ------------------
------------------
568| 5.51k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(boolvec, 0);
------------------
| | 109| 5.51k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 5.51k| do { \
| | | | 657| 5.51k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 5.51k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 5.51k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 5.51k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.51k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 5.51k]
| | | | ------------------
| | ------------------
| | 110| 5.51k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 5.51k| do { \
| | | | 604| 5.51k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 5.51k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 5.51k| * incorrect destructor function with the pointer */ \
| | | | 607| 5.51k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 5.51k]
| | | | ------------------
| | | | 608| 5.51k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 5.51k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 5.51k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 5.51k]
| | ------------------
------------------
569| 5.51k| ptr = boolvec;
570| 5.51k| }
571| 0| break;
572| |
573| 0| default:
------------------
| Branch (573:13): [True: 0, False: 65.4k]
------------------
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| 65.4k| }
576| |
577| 65.4k| igraph_i_attribute_record_set_type(attr, type, ptr);
578| 65.4k| IGRAPH_FINALLY_CLEAN(2);
579| 65.4k| }
580| |
581| 107k| return IGRAPH_SUCCESS;
582| 107k|}
igraph_i_attribute_init:
617| 17.5k|) {
618| 17.5k| graph->attr = NULL;
619| 17.5k| if (igraph_i_attribute_table) {
------------------
| Branch (619:9): [True: 17.5k, False: 0]
------------------
620| 17.5k| IGRAPH_CHECK(igraph_i_attribute_table->init(graph, attr));
------------------
| | 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: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
621| 17.5k| if (graph->attr == NULL) {
------------------
| Branch (621:13): [True: 0, False: 17.5k]
------------------
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| 17.5k| }
625| 17.5k| return IGRAPH_SUCCESS;
626| 17.5k|}
igraph_i_attribute_destroy:
628| 17.5k|void igraph_i_attribute_destroy(igraph_t *graph) {
629| 17.5k| if (graph->attr && igraph_i_attribute_table) {
------------------
| Branch (629:9): [True: 17.5k, False: 0]
| Branch (629:24): [True: 17.5k, False: 0]
------------------
630| 17.5k| igraph_i_attribute_table->destroy(graph);
631| 17.5k| }
632| | graph->attr = NULL;
633| 17.5k|}
igraph_i_attribute_add_vertices:
649| 35.1k|) {
650| 35.1k| if (igraph_i_attribute_table) {
------------------
| Branch (650:9): [True: 35.1k, False: 0]
------------------
651| 35.1k| return igraph_i_attribute_table->add_vertices(graph, nv, attr);
652| 35.1k| } else {
653| 0| return IGRAPH_SUCCESS;
654| 0| }
655| 35.1k|}
igraph_i_attribute_add_edges:
690| 17.5k|) {
691| 17.5k| if (igraph_i_attribute_table) {
------------------
| Branch (691:9): [True: 17.5k, False: 0]
------------------
692| 17.5k| return igraph_i_attribute_table->add_edges(graph, edges, attr);
693| 17.5k| } else {
694| 0| return IGRAPH_SUCCESS;
695| 0| }
696| 17.5k|}
igraph_i_attribute_get_info:
734| 10.7k| igraph_vector_int_t *etypes) {
735| 10.7k| if (igraph_i_attribute_table) {
------------------
| Branch (735:9): [True: 10.7k, False: 0]
------------------
736| 10.7k| return igraph_i_attribute_table->get_info(graph, gnames, gtypes,
737| 10.7k| vnames, vtypes,
738| 10.7k| enames, etypes);
739| 10.7k| } else {
740| 0| return IGRAPH_SUCCESS;
741| 0| }
742| 10.7k|}
igraph_i_attribute_has_attr:
746| 225k| const char *name) {
747| 225k| if (igraph_i_attribute_table) {
------------------
| Branch (747:9): [True: 225k, False: 0]
------------------
748| 225k| return igraph_i_attribute_table->has_attr(graph, type, name);
749| 225k| } else {
750| 0| return IGRAPH_SUCCESS;
751| 0| }
752| 225k|}
igraph_i_attribute_get_type:
757| 2.72k| const char *name) {
758| 2.72k| if (igraph_i_attribute_table) {
------------------
| Branch (758:9): [True: 2.72k, False: 0]
------------------
759| 2.72k| return igraph_i_attribute_table->get_type(graph, type, elemtype, name);
760| 2.72k| } else {
761| 0| return IGRAPH_SUCCESS;
762| 0| }
763| |
764| 2.72k|}
igraph_i_attribute_get_numeric_graph_attr:
768| 260| igraph_vector_t *value) {
769| 260| igraph_vector_clear(value);
770| 260| if (igraph_i_attribute_table) {
------------------
| Branch (770:9): [True: 260, False: 0]
------------------
771| 260| return igraph_i_attribute_table->get_numeric_graph_attr(graph, name, value);
772| 260| } else {
773| 0| return IGRAPH_SUCCESS;
774| 0| }
775| 260|}
igraph_i_attribute_get_numeric_vertex_attr:
780| 13.3k| igraph_vector_t *value) {
781| 13.3k| igraph_vector_clear(value);
782| 13.3k| if (igraph_i_attribute_table) {
------------------
| Branch (782:9): [True: 13.3k, False: 0]
------------------
783| 13.3k| return igraph_i_attribute_table->get_numeric_vertex_attr(graph, name, vs, value);
784| 13.3k| } else {
785| 0| return IGRAPH_SUCCESS;
786| 0| }
787| 13.3k|}
igraph_i_attribute_get_numeric_edge_attr:
792| 339k| igraph_vector_t *value) {
793| 339k| igraph_vector_clear(value);
794| 339k| if (igraph_i_attribute_table) {
------------------
| Branch (794:9): [True: 339k, False: 0]
------------------
795| 339k| return igraph_i_attribute_table->get_numeric_edge_attr(graph, name, es, value);
796| 339k| } else {
797| 0| return IGRAPH_SUCCESS;
798| 0| }
799| 339k|}
igraph_i_attribute_get_string_graph_attr:
803| 1.87k| igraph_strvector_t *value) {
804| 1.87k| igraph_strvector_clear(value);
805| 1.87k| if (igraph_i_attribute_table) {
------------------
| Branch (805:9): [True: 1.87k, False: 0]
------------------
806| 1.87k| return igraph_i_attribute_table->get_string_graph_attr(graph, name, value);
807| 1.87k| } else {
808| 0| return IGRAPH_SUCCESS;
809| 0| }
810| 1.87k|}
igraph_i_attribute_get_string_vertex_attr:
815| 98.0k| igraph_strvector_t *value) {
816| 98.0k| igraph_strvector_clear(value);
817| 98.0k| if (igraph_i_attribute_table) {
------------------
| Branch (817:9): [True: 98.0k, False: 0]
------------------
818| 98.0k| return igraph_i_attribute_table->get_string_vertex_attr(graph, name, vs, value);
819| 98.0k| } else {
820| 0| return IGRAPH_SUCCESS;
821| 0| }
822| 98.0k|}
igraph_i_attribute_get_string_edge_attr:
827| 929k| igraph_strvector_t *value) {
828| 929k| igraph_strvector_clear(value);
829| 929k| if (igraph_i_attribute_table) {
------------------
| Branch (829:9): [True: 929k, False: 0]
------------------
830| 929k| return igraph_i_attribute_table->get_string_edge_attr(graph, name, es, value);
831| 929k| } else {
832| 0| return IGRAPH_SUCCESS;
833| 0| }
834| 929k|}
igraph_i_attribute_get_bool_graph_attr:
838| 447| igraph_vector_bool_t *value) {
839| 447| igraph_vector_bool_clear(value);
840| 447| if (igraph_i_attribute_table) {
------------------
| Branch (840:9): [True: 447, False: 0]
------------------
841| 447| return igraph_i_attribute_table->get_bool_graph_attr(graph, name, value);
842| 447| } else {
843| 0| return IGRAPH_SUCCESS;
844| 0| }
845| 447|}
igraph_i_attribute_get_bool_vertex_attr:
850| 14.4k| igraph_vector_bool_t *value) {
851| 14.4k| igraph_vector_bool_clear(value);
852| 14.4k| if (igraph_i_attribute_table) {
------------------
| Branch (852:9): [True: 14.4k, False: 0]
------------------
853| 14.4k| return igraph_i_attribute_table->get_bool_vertex_attr(graph, name, vs, value);
854| 14.4k| } else {
855| 0| return IGRAPH_SUCCESS;
856| 0| }
857| 14.4k|}
igraph_i_attribute_get_bool_edge_attr:
862| 17.3k| igraph_vector_bool_t *value) {
863| 17.3k| igraph_vector_bool_clear(value);
864| 17.3k| if (igraph_i_attribute_table) {
------------------
| Branch (864:9): [True: 17.3k, False: 0]
------------------
865| 17.3k| return igraph_i_attribute_table->get_bool_edge_attr(graph, name, es, value);
866| 17.3k| } else {
867| 0| return IGRAPH_SUCCESS;
868| 0| }
869| 17.3k|}
igraph_set_attribute_table:
895| 21.3k|igraph_set_attribute_table(const igraph_attribute_table_t * table) {
896| 21.3k| igraph_attribute_table_t *old = igraph_i_attribute_table;
897| 21.3k| igraph_i_attribute_table = (igraph_attribute_table_t*) table;
898| 21.3k| return old;
899| 21.3k|}
attributes.c:igraph_i_attribute_record_destroy_values:
185| 134k|static void igraph_i_attribute_record_destroy_values(igraph_attribute_record_t *attr) {
186| 134k| IGRAPH_ASSERT(attr != NULL);
------------------
| | 924| 134k| do { \
| | 925| 134k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 134k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 134k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 134k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 134k]
| | ------------------
------------------
187| |
188| 134k| if (attr->value.as_raw) {
------------------
| Branch (188:9): [True: 65.4k, False: 69.5k]
------------------
189| 65.4k| switch (attr->type) {
190| 12.2k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (190:13): [True: 12.2k, False: 53.1k]
------------------
191| 12.2k| igraph_vector_destroy(attr->value.as_vector);
192| 12.2k| break;
193| |
194| 47.6k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (194:13): [True: 47.6k, False: 17.8k]
------------------
195| 47.6k| igraph_strvector_destroy(attr->value.as_strvector);
196| 47.6k| break;
197| |
198| 5.51k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (198:13): [True: 5.51k, False: 59.9k]
------------------
199| 5.51k| igraph_vector_bool_destroy(attr->value.as_vector_bool);
200| 5.51k| break;
201| |
202| 0| default:
------------------
| Branch (202:13): [True: 0, False: 65.4k]
------------------
203| 0| break;
204| 65.4k| }
205| |
206| 65.4k| igraph_free(attr->value.as_raw);
207| 65.4k| attr->value.as_raw = NULL;
208| 65.4k| }
209| |
210| 134k| switch (attr->type) {
211| 12.2k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (211:9): [True: 12.2k, False: 122k]
------------------
212| 12.2k| attr->default_value.numeric = 0;
213| 12.2k| break;
214| |
215| 47.6k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (215:9): [True: 47.6k, False: 87.3k]
------------------
216| 47.6k| if (attr->default_value.string) {
------------------
| Branch (216:17): [True: 809, False: 46.7k]
------------------
217| 809| igraph_free(attr->default_value.string);
218| 809| attr->default_value.string = NULL;
219| 809| }
220| 47.6k| break;
221| |
222| 5.51k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (222:9): [True: 5.51k, False: 129k]
------------------
223| 5.51k| attr->default_value.boolean = 0;
224| 5.51k| break;
225| |
226| 69.5k| default:
------------------
| Branch (226:9): [True: 69.5k, False: 65.4k]
------------------
227| 69.5k| break;
228| 134k| }
229| |
230| 134k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
231| 134k|}
attributes.c:igraph_i_attribute_record_set_type:
506| 65.4k|) {
507| 65.4k| bool type_changed = attr->type != type;
508| |
509| 65.4k| if (type_changed || attr->value.as_raw != ptr) {
------------------
| Branch (509:9): [True: 65.4k, False: 0]
| Branch (509:25): [True: 0, False: 0]
------------------
510| 65.4k| igraph_i_attribute_record_destroy_values(attr);
511| 65.4k| attr->type = type;
512| 65.4k| attr->value.as_raw = ptr;
513| 65.4k| }
514| |
515| 65.4k| if (type_changed && type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (515:9): [True: 65.4k, False: 0]
| Branch (515:25): [True: 12.2k, False: 53.1k]
------------------
516| 12.2k| IGRAPH_ASSERT(
------------------
| | 924| 12.2k| do { \
| | 925| 12.2k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 12.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 12.2k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 12.2k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 12.2k]
| | ------------------
------------------
517| 12.2k| igraph_attribute_record_set_default_numeric(attr, IGRAPH_NAN) == IGRAPH_SUCCESS
518| 12.2k| );
519| 12.2k| }
520| 65.4k|}
attributes.c:igraph_i_attribute_record_list_init_item:
596| 41.6k|) {
597| 41.6k| IGRAPH_UNUSED(list);
------------------
| | 30| 41.6k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
598| | return igraph_attribute_record_init(item, NULL, IGRAPH_ATTRIBUTE_UNSPECIFIED);
599| 41.6k|}
attributes.c:igraph_i_attribute_record_list_copy_item:
603| 2.44k|) {
604| 2.44k| return igraph_attribute_record_init_copy(dest, source);
605| 2.44k|}
attributes.c:igraph_i_attribute_record_list_destroy_item:
607| 64.9k|static void igraph_i_attribute_record_list_destroy_item(igraph_attribute_record_t* item) {
608| 64.9k| igraph_attribute_record_destroy(item);
609| 64.9k|}
igraph_i_property_cache_init:
32| 17.5k|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) {
33| 17.5k| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32);
------------------
| | 68| 17.5k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
34| |
35| 17.5k| memset(cache->value, 0, sizeof(cache->value));
36| 17.5k| cache->known = 0;
37| 17.5k| return IGRAPH_SUCCESS;
38| 17.5k|}
igraph_i_property_cache_destroy:
53| 17.5k|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) {
54| 17.5k| IGRAPH_UNUSED(cache);
------------------
| | 30| 17.5k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
55| | /* Nothing to do */
56| 17.5k|}
igraph_i_property_cache_invalidate_conditionally:
182| 52.7k|) {
183| 52.7k| uint32_t invalidate = ~keep_always;
184| 52.7k| uint32_t mask;
185| 52.7k| uint32_t maybe_keep;
186| 52.7k| igraph_bool_t cached_value;
187| |
188| 52.7k| assert(graph->cache != NULL);
------------------
| Branch (188:5): [True: 0, False: 52.7k]
| Branch (188:5): [True: 52.7k, 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| 52.7k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true);
197| |
198| 52.7k| if (maybe_keep) {
------------------
| Branch (198:9): [True: 0, False: 52.7k]
------------------
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| 52.7k| graph->cache->known &= ~invalidate;
216| 52.7k|}
cattributes.c:igraph_i_cattribute_init:
195| 17.5k|) {
196| 17.5k| igraph_i_cattributes_t *nattr;
197| |
198| 17.5k| nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t);
------------------
| | 33| 17.5k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 35.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: 17.5k, Folded]
| | | | ------------------
| | ------------------
------------------
199| 17.5k| IGRAPH_CHECK_OOM(nattr, "Insufficient memory to allocate attribute storage.");
------------------
| | 709| 17.5k| do { \
| | 710| 17.5k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 17.5k]
| | ------------------
------------------
200| 17.5k| IGRAPH_FINALLY(igraph_free, nattr);
------------------
| | 603| 17.5k| do { \
| | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | 607| 17.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.5k]
| | ------------------
| | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.5k]
| | ------------------
------------------
201| |
202| 17.5k| if (attr) {
------------------
| Branch (202:9): [True: 10.6k, False: 6.90k]
------------------
203| 10.6k| IGRAPH_CHECK(igraph_attribute_record_list_init_copy(&nattr->gal, attr));
------------------
| | 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]
| | ------------------
------------------
204| 10.6k| } else {
205| 6.90k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->gal, 0));
------------------
| | 656| 6.90k| do { \
| | 657| 6.90k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 6.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 6.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.90k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 6.90k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.90k]
| | ------------------
------------------
206| 6.90k| }
207| 17.5k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->gal);
------------------
| | 603| 17.5k| do { \
| | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | 607| 17.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.5k]
| | ------------------
| | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.5k]
| | ------------------
------------------
208| |
209| 17.5k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->val, 0));
------------------
| | 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: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
210| 17.5k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->val);
------------------
| | 603| 17.5k| do { \
| | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | 607| 17.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.5k]
| | ------------------
| | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.5k]
| | ------------------
------------------
211| |
212| 17.5k| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->eal, 0));
------------------
| | 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: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
213| 17.5k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->eal);
------------------
| | 603| 17.5k| do { \
| | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | 607| 17.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.5k]
| | ------------------
| | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.5k]
| | ------------------
------------------
214| |
215| 17.5k| graph->attr = nattr;
216| 17.5k| IGRAPH_FINALLY_CLEAN(4);
217| |
218| 17.5k| return IGRAPH_SUCCESS;
219| 17.5k|}
cattributes.c:igraph_i_cattribute_destroy:
221| 17.5k|static void igraph_i_cattribute_destroy(igraph_t *graph) {
222| 17.5k| igraph_i_cattributes_t *attr = graph->attr;
223| 17.5k| igraph_attribute_record_list_destroy(&attr->eal);
224| 17.5k| igraph_attribute_record_list_destroy(&attr->val);
225| 17.5k| igraph_attribute_record_list_destroy(&attr->gal);
226| | IGRAPH_FREE(graph->attr); /* sets to NULL */
------------------
| | 36| 17.5k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
227| 17.5k|}
cattributes.c:igraph_i_cattribute_add_vertices:
373| 35.1k|) {
374| 35.1k| igraph_i_cattributes_t *attr = graph->attr;
375| 35.1k| return igraph_i_cattribute_add_vertices_or_edges(&attr->val, igraph_vcount(graph), nv, nattr);
376| 35.1k|}
cattributes.c:igraph_i_cattribute_add_vertices_or_edges:
344| 52.7k|) {
345| 52.7k| igraph_int_t origlen = newlen - nv;
346| 52.7k| igraph_error_t err = igraph_i_cattribute_add_vertices_or_edges_inner(
347| 52.7k| val, newlen, nv, nattr
348| 52.7k| );
349| |
350| 52.7k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (350:9): [True: 0, False: 52.7k]
------------------
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| 52.7k| return err;
368| 52.7k|}
cattributes.c:igraph_i_cattribute_add_vertices_or_edges_inner:
269| 52.7k|) {
270| 52.7k| igraph_int_t length;
271| 52.7k| igraph_int_t nattrno = nattr == NULL ? 0 : igraph_attribute_record_list_size(nattr);
------------------
| Branch (271:28): [True: 24.2k, False: 28.5k]
------------------
272| 52.7k| igraph_int_t origlen = newlen - nv;
273| |
274| 52.7k| IGRAPH_ASSERT(origlen >= 0);
------------------
| | 924| 52.7k| do { \
| | 925| 52.7k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 52.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 52.7k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 52.7k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 52.7k]
| | ------------------
------------------
275| |
276| | /* Find all the attributes that are newly added, and create new value vectors
277| | * for them in the original graph */
278| 82.8k| for (igraph_int_t i = 0; i < nattrno; i++) {
------------------
| Branch (278:30): [True: 30.0k, False: 52.7k]
------------------
279| 30.0k| const igraph_attribute_record_t *nattr_entry = igraph_attribute_record_list_get_ptr(nattr, i);
280| 30.0k| const char *nname = nattr_entry->name;
281| 30.0k| IGRAPH_CHECK(igraph_i_cattribute_find_or_create(val, nname, nattr_entry->type, origlen, NULL));
------------------
| | 656| 30.0k| do { \
| | 657| 30.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 30.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 30.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 30.0k]
| | ------------------
------------------
282| 30.0k| }
283| |
284| | /* Now append the new values */
285| 52.7k| length = igraph_attribute_record_list_size(val);
286| 82.8k| for (igraph_int_t i = 0; i < length; i++) {
------------------
| Branch (286:30): [True: 30.0k, False: 52.7k]
------------------
287| 30.0k| igraph_attribute_record_t *oldrec = igraph_attribute_record_list_get_ptr(val, i);
288| 30.0k| const igraph_attribute_record_t *newrec = nattr
------------------
| Branch (288:51): [True: 30.0k, False: 0]
------------------
289| 30.0k| ? igraph_i_cattribute_find_const(nattr, oldrec->name, oldrec->type)
290| 30.0k| : NULL;
291| |
292| 30.0k| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == origlen);
------------------
| | 924| 30.0k| do { \
| | 925| 30.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 30.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 30.0k]
| | ------------------
------------------
293| |
294| 30.0k| if (newrec) {
------------------
| Branch (294:13): [True: 30.0k, False: 0]
------------------
295| | /* This attribute is present in nattr */
296| 30.0k| switch (oldrec->type) {
297| 5.78k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (297:13): [True: 5.78k, False: 24.2k]
------------------
298| 5.78k| if (nv != igraph_vector_size(newrec->value.as_vector)) {
------------------
| Branch (298:21): [True: 0, False: 5.78k]
------------------
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.78k| IGRAPH_CHECK(igraph_vector_append(
------------------
| | 656| 5.78k| do { \
| | 657| 5.78k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.78k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.78k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.78k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.78k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.78k]
| | ------------------
------------------
302| 5.78k| oldrec->value.as_vector, newrec->value.as_vector
303| 5.78k| ));
304| 5.78k| break;
305| 21.8k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (305:13): [True: 21.8k, False: 8.12k]
------------------
306| 21.8k| if (nv != igraph_strvector_size(newrec->value.as_strvector)) {
------------------
| Branch (306:21): [True: 0, False: 21.8k]
------------------
307| 0| IGRAPH_ERROR("Invalid string attribute length.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
308| 0| }
309| 21.8k| IGRAPH_CHECK(igraph_strvector_append(
------------------
| | 656| 21.8k| do { \
| | 657| 21.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 21.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 21.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 21.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| 21.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 21.8k]
| | ------------------
------------------
310| 21.8k| oldrec->value.as_strvector, newrec->value.as_strvector
311| 21.8k| ));
312| 21.8k| break;
313| 21.8k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (313:13): [True: 2.34k, False: 27.6k]
------------------
314| 2.34k| if (nv != igraph_vector_bool_size(newrec->value.as_vector_bool)) {
------------------
| Branch (314:21): [True: 0, False: 2.34k]
------------------
315| 0| IGRAPH_ERROR("Invalid boolean attribute length.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
316| 0| }
317| 2.34k| IGRAPH_CHECK(igraph_vector_bool_append(
------------------
| | 656| 2.34k| do { \
| | 657| 2.34k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.34k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.34k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.34k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.34k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.34k]
| | ------------------
------------------
318| 2.34k| oldrec->value.as_vector_bool, newrec->value.as_vector_bool
319| 2.34k| ));
320| 2.34k| break;
321| 2.34k| default:
------------------
| Branch (321:13): [True: 0, False: 30.0k]
------------------
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| 30.0k| }
328| 30.0k| } 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| 30.0k| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == newlen);
------------------
| | 924| 30.0k| do { \
| | 925| 30.0k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.0k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 30.0k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 30.0k]
| | ------------------
------------------
335| 30.0k| }
336| |
337| 52.7k| return IGRAPH_SUCCESS;
338| 52.7k|}
cattributes.c:igraph_i_cattribute_find_const:
90| 30.0k|) {
91| 30.0k| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name);
92| 30.0k| const igraph_attribute_record_t *rec;
93| |
94| 30.0k| if (index >= 0) {
------------------
| Branch (94:9): [True: 30.0k, False: 0]
------------------
95| 30.0k| rec = igraph_attribute_record_list_get_ptr(attrs, index);
96| 30.0k| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) {
------------------
| Branch (96:13): [True: 0, False: 30.0k]
| Branch (96:53): [True: 30.0k, False: 0]
------------------
97| 30.0k| return rec;
98| 30.0k| }
99| 30.0k| }
100| |
101| 0| return NULL;
102| 30.0k|}
cattributes.c:igraph_i_cattribute_add_edges:
1463| 17.5k|) {
1464| 17.5k| igraph_int_t ne = igraph_vector_int_size(edges) / 2;
1465| 17.5k| igraph_i_cattributes_t *attr = graph->attr;
1466| 17.5k| return igraph_i_cattribute_add_vertices_or_edges(&attr->eal, igraph_ecount(graph), ne, nattr);
1467| 17.5k|}
cattributes.c:igraph_i_cattribute_get_info:
1498| 10.7k| igraph_vector_int_t *etypes) {
1499| |
1500| 10.7k| igraph_strvector_t *names[3] = { gnames, vnames, enames };
1501| 10.7k| igraph_vector_int_t *types[3] = { gtypes, vtypes, etypes };
1502| 10.7k| igraph_i_cattributes_t *at = graph->attr;
1503| 10.7k| igraph_attribute_record_list_t *attr[3] = { &at->gal, &at->val, &at->eal };
1504| |
1505| 42.9k| for (igraph_int_t i = 0; i < 3; i++) {
------------------
| Branch (1505:30): [True: 32.2k, False: 10.7k]
------------------
1506| 32.2k| igraph_strvector_t *n = names[i];
1507| 32.2k| igraph_vector_int_t *t = types[i];
1508| 32.2k| const igraph_attribute_record_list_t *al = attr[i];
1509| 32.2k| igraph_int_t len = igraph_attribute_record_list_size(al);
1510| |
1511| 32.2k| if (n) {
------------------
| Branch (1511:13): [True: 32.2k, False: 0]
------------------
1512| 32.2k| IGRAPH_CHECK(igraph_strvector_resize(n, len));
------------------
| | 656| 32.2k| do { \
| | 657| 32.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.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| 32.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.2k]
| | ------------------
------------------
1513| 32.2k| }
1514| 32.2k| if (t) {
------------------
| Branch (1514:13): [True: 32.2k, False: 0]
------------------
1515| 32.2k| IGRAPH_CHECK(igraph_vector_int_resize(t, len));
------------------
| | 656| 32.2k| do { \
| | 657| 32.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 32.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 32.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 32.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| 32.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 32.2k]
| | ------------------
------------------
1516| 32.2k| }
1517| |
1518| 59.4k| for (igraph_int_t j = 0; j < len; j++) {
------------------
| Branch (1518:34): [True: 27.2k, False: 32.2k]
------------------
1519| 27.2k| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(al, j);
1520| 27.2k| const char *name = rec->name;
1521| 27.2k| igraph_attribute_type_t type = rec->type;
1522| 27.2k| if (n) {
------------------
| Branch (1522:17): [True: 27.2k, False: 0]
------------------
1523| 27.2k| IGRAPH_CHECK(igraph_strvector_set(n, j, name));
------------------
| | 656| 27.2k| do { \
| | 657| 27.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 27.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 27.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 27.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| 27.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 27.2k]
| | ------------------
------------------
1524| 27.2k| }
1525| 27.2k| if (t) {
------------------
| Branch (1525:17): [True: 27.2k, False: 0]
------------------
1526| 27.2k| VECTOR(*t)[j] = type;
------------------
| | 60| 27.2k|#define VECTOR(v) ((v).stor_begin)
------------------
1527| 27.2k| }
1528| 27.2k| }
1529| 32.2k| }
1530| |
1531| 10.7k| return IGRAPH_SUCCESS;
1532| 10.7k|}
cattributes.c:igraph_i_cattribute_has_attr:
1536| 225k| const char *name) {
1537| 225k| const igraph_i_cattributes_t *at = graph->attr;
1538| 225k| switch (type) {
1539| 0| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (1539:5): [True: 0, False: 225k]
------------------
1540| 0| return igraph_i_cattribute_find_index(&at->gal, name) >= 0;
1541| 139k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (1541:5): [True: 139k, False: 85.8k]
------------------
1542| 139k| return igraph_i_cattribute_find_index(&at->val, name) >= 0;
1543| 85.8k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (1543:5): [True: 85.8k, False: 139k]
------------------
1544| 85.8k| return igraph_i_cattribute_find_index(&at->eal, name) >= 0;
1545| 0| default:
------------------
| Branch (1545:5): [True: 0, False: 225k]
------------------
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| 225k| }
1549| |
1550| 0| return false;
1551| 225k|}
cattributes.c:igraph_i_cattribute_get_type:
1556| 2.72k| const char *name) {
1557| 2.72k| igraph_attribute_record_t *rec;
1558| 2.72k| igraph_i_cattributes_t *at = graph->attr;
1559| 2.72k| igraph_attribute_record_list_t *al;
1560| |
1561| 2.72k| switch (elemtype) {
1562| 0| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (1562:5): [True: 0, False: 2.72k]
------------------
1563| 0| al = &at->gal;
1564| 0| break;
1565| 1.66k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (1565:5): [True: 1.66k, False: 1.06k]
------------------
1566| 1.66k| al = &at->val;
1567| 1.66k| break;
1568| 1.06k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (1568:5): [True: 1.06k, False: 1.66k]
------------------
1569| 1.06k| al = &at->eal;
1570| 1.06k| break;
1571| 0| default:
------------------
| Branch (1571:5): [True: 0, False: 2.72k]
------------------
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.72k| }
1575| |
1576| 2.72k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(al, name, IGRAPH_ATTRIBUTE_UNSPECIFIED, &rec));
------------------
| | 656| 2.72k| do { \
| | 657| 2.72k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.72k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.72k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.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| 2.72k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.72k]
| | ------------------
------------------
1577| 2.72k| *type = rec->type;
1578| |
1579| 2.72k| return IGRAPH_SUCCESS;
1580| 2.72k|}
cattributes.c:igraph_i_cattribute_find_or_return:
113| 1.41M|) {
114| 1.41M| igraph_attribute_record_t *rec;
115| |
116| 1.41M| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED);
117| 1.41M| if (!rec) {
------------------
| Branch (117:9): [True: 12, False: 1.41M]
------------------
118| 12| IGRAPH_ERRORF("Attribute '%s' does not exist.", IGRAPH_EINVAL, name);
------------------
| | 464| 12| do { \
| | 465| 12| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 12| igraph_errno, __VA_ARGS__) ; \
| | 467| 12| return igraph_errno; \
| | 468| 12| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
119| 12| }
120| |
121| 1.41M| if (type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (121:9): [True: 1.41M, False: 2.72k]
------------------
122| 1.41M| IGRAPH_CHECK(igraph_attribute_record_check_type(rec, type));
------------------
| | 656| 1.41M| do { \
| | 657| 1.41M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.41M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.41M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 1.41M]
| | | | ------------------
| | ------------------
| | 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.41M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.41M]
| | ------------------
------------------
123| 1.41M| }
124| |
125| 1.41M| if (ptr) {
------------------
| Branch (125:9): [True: 1.41M, False: 0]
------------------
126| 1.41M| *ptr = rec;
127| 1.41M| }
128| |
129| 1.41M| return IGRAPH_SUCCESS;
130| 1.41M|}
cattributes.c:igraph_i_cattribute_get_numeric_graph_attr:
1584| 260|) {
1585| 260| igraph_i_cattributes_t *attr = graph->attr;
1586| 260| igraph_attribute_record_list_t *gal = &attr->gal;
1587| 260| igraph_attribute_record_t *rec;
1588| |
1589| 260| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_NUMERIC, &rec));
------------------
| | 656| 260| do { \
| | 657| 260| igraph_error_t igraph_i_ret = (expr); \
| | 658| 260| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 260| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 260]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 260| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 260]
| | ------------------
------------------
1590| 260| IGRAPH_CHECK(igraph_vector_push_back(value, VECTOR(*rec->value.as_vector)[0]));
------------------
| | 656| 260| do { \
| | 657| 260| igraph_error_t igraph_i_ret = (expr); \
| | 658| 260| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 260| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 260]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 260| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 260]
| | ------------------
------------------
1591| |
1592| 260| return IGRAPH_SUCCESS;
1593| 260|}
cattributes.c:igraph_i_cattribute_get_string_graph_attr:
1610| 1.87k|) {
1611| 1.87k| igraph_i_cattributes_t *attr = graph->attr;
1612| 1.87k| igraph_attribute_record_list_t *gal = &attr->gal;
1613| 1.87k| igraph_attribute_record_t *rec;
1614| |
1615| 1.87k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 656| 1.87k| do { \
| | 657| 1.87k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.87k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.87k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.87k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.87k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.87k]
| | ------------------
------------------
1616| 1.87k| IGRAPH_CHECK(igraph_strvector_push_back(value, igraph_strvector_get(rec->value.as_strvector, 0)));
------------------
| | 656| 1.87k| do { \
| | 657| 1.87k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.87k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.87k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.87k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 1.87k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.87k]
| | ------------------
------------------
1617| |
1618| 1.87k| return IGRAPH_SUCCESS;
1619| 1.87k|}
cattributes.c:igraph_i_cattribute_get_bool_graph_attr:
1597| 447|) {
1598| 447| igraph_i_cattributes_t *attr = graph->attr;
1599| 447| igraph_attribute_record_list_t *gal = &attr->gal;
1600| 447| igraph_attribute_record_t *rec;
1601| |
1602| 447| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(gal, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 447| do { \
| | 657| 447| igraph_error_t igraph_i_ret = (expr); \
| | 658| 447| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 447| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 447]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 447| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 447]
| | ------------------
------------------
1603| 447| IGRAPH_CHECK(igraph_vector_bool_push_back(value, VECTOR(*rec->value.as_vector_bool)[0]));
------------------
| | 656| 447| do { \
| | 657| 447| igraph_error_t igraph_i_ret = (expr); \
| | 658| 447| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 447| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 447]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 447| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 447]
| | ------------------
------------------
1604| |
1605| 447| return IGRAPH_SUCCESS;
1606| 447|}
cattributes.c:igraph_i_cattribute_get_numeric_vertex_attr:
1624| 13.3k| igraph_vector_t *value) {
1625| 13.3k| igraph_i_cattributes_t *attr = graph->attr;
1626| 13.3k| igraph_attribute_record_list_t *val = &attr->val;
1627| 13.3k| igraph_attribute_record_t *rec;
1628| 13.3k| const igraph_vector_t *num;
1629| |
1630| 13.3k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_NUMERIC, &rec));
------------------
| | 656| 13.3k| do { \
| | 657| 13.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.3k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 13.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.3k]
| | ------------------
------------------
1631| |
1632| 13.3k| num = rec->value.as_vector;
1633| 13.3k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1633:9): [True: 66, False: 13.3k]
------------------
1634| 66| IGRAPH_CHECK(igraph_vector_append(value, num));
------------------
| | 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]
| | ------------------
------------------
1635| 13.3k| } else {
1636| 13.3k| igraph_vit_t it;
1637| 13.3k| igraph_int_t i = igraph_vector_size(value);
1638| 13.3k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 656| 13.3k| do { \
| | 657| 13.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.3k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 13.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.3k]
| | ------------------
------------------
1639| 13.3k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 603| 13.3k| do { \
| | 604| 13.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 13.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 13.3k| * incorrect destructor function with the pointer */ \
| | 607| 13.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 13.3k]
| | ------------------
| | 608| 13.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 13.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 13.3k]
| | ------------------
------------------
1640| 13.3k| IGRAPH_CHECK(igraph_vector_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 656| 13.3k| do { \
| | 657| 13.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 13.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 13.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13.3k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 13.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 13.3k]
| | ------------------
------------------
1641| 26.6k| for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 179| 26.6k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end)
------------------
for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 167| 13.3k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1641:16): [True: 13.3k, False: 13.3k]
------------------
1642| 13.3k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 13.3k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 13.3k, False: 0]
| | ------------------
| | 215| 13.3k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1643| 13.3k| VECTOR(*value)[i] = VECTOR(*num)[v];
------------------
| | 60| 13.3k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*num)[v];
------------------
| | 60| 13.3k|#define VECTOR(v) ((v).stor_begin)
------------------
1644| 13.3k| }
1645| 13.3k| igraph_vit_destroy(&it);
1646| 13.3k| IGRAPH_FINALLY_CLEAN(1);
1647| 13.3k| }
1648| |
1649| 13.3k| return IGRAPH_SUCCESS;
1650| 13.3k|}
cattributes.c:igraph_i_cattribute_get_string_vertex_attr:
1686| 98.0k| igraph_strvector_t *value) {
1687| 98.0k| igraph_i_cattributes_t *attr = graph->attr;
1688| 98.0k| igraph_attribute_record_list_t *val = &attr->val;
1689| 98.0k| igraph_attribute_record_t *rec;
1690| 98.0k| const igraph_strvector_t *str;
1691| |
1692| 98.0k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 656| 98.0k| do { \
| | 657| 98.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 98.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 98.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 98.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| 98.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 98.0k]
| | ------------------
------------------
1693| |
1694| 98.0k| str = rec->value.as_strvector;
1695| 98.0k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1695:9): [True: 1.23k, False: 96.8k]
------------------
1696| 1.23k| igraph_strvector_clear(value);
1697| 1.23k| IGRAPH_CHECK(igraph_strvector_append(value, str));
------------------
| | 656| 1.23k| do { \
| | 657| 1.23k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.23k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.23k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.23k]
| | ------------------
------------------
1698| 96.8k| } else {
1699| 96.8k| igraph_vit_t it;
1700| 96.8k| igraph_int_t i = igraph_strvector_size(value);
1701| 96.8k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 656| 96.8k| do { \
| | 657| 96.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 96.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 96.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 96.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| 96.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 96.8k]
| | ------------------
------------------
1702| 96.8k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 603| 96.8k| do { \
| | 604| 96.8k| /* the following branch makes the compiler check the compatibility of \
| | 605| 96.8k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 96.8k| * incorrect destructor function with the pointer */ \
| | 607| 96.8k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 96.8k]
| | ------------------
| | 608| 96.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 96.8k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 96.8k]
| | ------------------
------------------
1703| 96.8k| IGRAPH_CHECK(igraph_strvector_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 656| 96.8k| do { \
| | 657| 96.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 96.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 96.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 96.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| 96.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 96.8k]
| | ------------------
------------------
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.8k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1704:16): [True: 96.8k, False: 96.8k]
------------------
1705| 96.8k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 96.8k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 96.8k, False: 0]
| | ------------------
| | 215| 96.8k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1706| 96.8k| IGRAPH_CHECK(igraph_strvector_set(value, i, igraph_strvector_get(str, v)));
------------------
| | 656| 96.8k| do { \
| | 657| 96.8k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 96.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 96.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 96.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| 96.8k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 96.8k]
| | ------------------
------------------
1707| 96.8k| }
1708| 96.8k| igraph_vit_destroy(&it);
1709| 96.8k| IGRAPH_FINALLY_CLEAN(1);
1710| 96.8k| }
1711| |
1712| 98.0k| return IGRAPH_SUCCESS;
1713| 98.0k|}
cattributes.c:igraph_i_cattribute_get_bool_vertex_attr:
1655| 14.4k| igraph_vector_bool_t *value) {
1656| 14.4k| igraph_i_cattributes_t *attr = graph->attr;
1657| 14.4k| igraph_attribute_record_list_t *val = &attr->val;
1658| 14.4k| igraph_attribute_record_t *rec;
1659| 14.4k| const igraph_vector_bool_t *log;
1660| |
1661| 14.4k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(val, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 14.4k| do { \
| | 657| 14.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.4k]
| | ------------------
------------------
1662| |
1663| 14.4k| log = rec->value.as_vector_bool;
1664| 14.4k| if (igraph_vs_is_all(&vs)) {
------------------
| Branch (1664:9): [True: 30, False: 14.4k]
------------------
1665| 30| IGRAPH_CHECK(igraph_vector_bool_append(value, log));
------------------
| | 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]
| | ------------------
------------------
1666| 14.4k| } else {
1667| 14.4k| igraph_vit_t it;
1668| 14.4k| igraph_int_t i = igraph_vector_bool_size(value);
1669| 14.4k| IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
------------------
| | 656| 14.4k| do { \
| | 657| 14.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.4k]
| | ------------------
------------------
1670| 14.4k| IGRAPH_FINALLY(igraph_vit_destroy, &it);
------------------
| | 603| 14.4k| do { \
| | 604| 14.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 14.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 14.4k| * incorrect destructor function with the pointer */ \
| | 607| 14.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 14.4k]
| | ------------------
| | 608| 14.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 14.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 14.4k]
| | ------------------
------------------
1671| 14.4k| IGRAPH_CHECK(igraph_vector_bool_resize(value, i + IGRAPH_VIT_SIZE(it)));
------------------
| | 656| 14.4k| do { \
| | 657| 14.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.4k]
| | ------------------
------------------
1672| 28.9k| for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 179| 28.9k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end)
------------------
for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
------------------
| | 167| 14.4k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos))
------------------
| Branch (1672:16): [True: 14.4k, False: 14.4k]
------------------
1673| 14.4k| igraph_int_t v = IGRAPH_VIT_GET(it);
------------------
| | 214| 14.4k| ((igraph_int_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \
| | ------------------
| | | Branch (214:21): [True: 14.4k, False: 0]
| | ------------------
| | 215| 14.4k| VECTOR(*(vit).vec)[(vit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1674| 14.4k| VECTOR(*value)[i] = VECTOR(*log)[v];
------------------
| | 60| 14.4k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*log)[v];
------------------
| | 60| 14.4k|#define VECTOR(v) ((v).stor_begin)
------------------
1675| 14.4k| }
1676| 14.4k| igraph_vit_destroy(&it);
1677| 14.4k| IGRAPH_FINALLY_CLEAN(1);
1678| 14.4k| }
1679| |
1680| 14.4k| return IGRAPH_SUCCESS;
1681| 14.4k|}
cattributes.c:igraph_i_cattribute_get_numeric_edge_attr:
1717| 339k|) {
1718| 339k| igraph_i_cattributes_t *attr = graph->attr;
1719| 339k| igraph_attribute_record_list_t *eal = &attr->eal;
1720| 339k| igraph_attribute_record_t *rec;
1721| 339k| const igraph_vector_t *num;
1722| |
1723| 339k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_NUMERIC, &rec));
------------------
| | 656| 339k| do { \
| | 657| 339k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 339k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 339k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 339k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 339k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 339k]
| | ------------------
------------------
1724| |
1725| 339k| num = rec->value.as_vector;
1726| 339k| if (igraph_es_is_all(&es)) {
------------------
| Branch (1726:9): [True: 523, False: 339k]
------------------
1727| 523| IGRAPH_CHECK(igraph_vector_append(value, num));
------------------
| | 656| 523| do { \
| | 657| 523| igraph_error_t igraph_i_ret = (expr); \
| | 658| 523| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 523| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 523]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 523| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 523]
| | ------------------
------------------
1728| 339k| } else {
1729| 339k| igraph_eit_t it;
1730| 339k| igraph_int_t i = igraph_vector_size(value);
1731| 339k| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 656| 339k| do { \
| | 657| 339k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 339k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 339k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 339k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 339k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 339k]
| | ------------------
------------------
1732| 339k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 339k| do { \
| | 604| 339k| /* the following branch makes the compiler check the compatibility of \
| | 605| 339k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 339k| * incorrect destructor function with the pointer */ \
| | 607| 339k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 339k]
| | ------------------
| | 608| 339k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 339k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 339k]
| | ------------------
------------------
1733| 339k| IGRAPH_CHECK(igraph_vector_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 656| 339k| do { \
| | 657| 339k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 339k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 339k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 339k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 339k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 339k]
| | ------------------
------------------
1734| 678k| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 678k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 339k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1734:16): [True: 339k, False: 339k]
------------------
1735| 339k| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 339k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 339k, False: 0]
| | ------------------
| | 406| 339k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1736| 339k| VECTOR(*value)[i] = VECTOR(*num)[e];
------------------
| | 60| 339k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*num)[e];
------------------
| | 60| 339k|#define VECTOR(v) ((v).stor_begin)
------------------
1737| 339k| }
1738| 339k| igraph_eit_destroy(&it);
1739| 339k| IGRAPH_FINALLY_CLEAN(1);
1740| 339k| }
1741| |
1742| 339k| return IGRAPH_SUCCESS;
1743| 339k|}
cattributes.c:igraph_i_cattribute_get_string_edge_attr:
1748| 929k|) {
1749| 929k| igraph_i_cattributes_t *attr = graph->attr;
1750| 929k| igraph_attribute_record_list_t *eal = &attr->eal;
1751| 929k| igraph_attribute_record_t *rec;
1752| 929k| const igraph_strvector_t *str;
1753| |
1754| 929k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_STRING, &rec));
------------------
| | 656| 929k| do { \
| | 657| 929k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 929k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 929k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 929k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 929k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 929k]
| | ------------------
------------------
1755| |
1756| 929k| str = rec->value.as_strvector;
1757| 929k| if (igraph_es_is_all(&es)) {
------------------
| Branch (1757:9): [True: 51, False: 929k]
------------------
1758| 51| IGRAPH_CHECK(igraph_strvector_append(value, str));
------------------
| | 656| 51| do { \
| | 657| 51| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 51| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51]
| | ------------------
------------------
1759| 929k| } else {
1760| 929k| igraph_eit_t it;
1761| 929k| igraph_int_t i = igraph_strvector_size(value);
1762| 929k| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 656| 929k| do { \
| | 657| 929k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 929k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 929k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 929k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 929k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 929k]
| | ------------------
------------------
1763| 929k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 929k| do { \
| | 604| 929k| /* the following branch makes the compiler check the compatibility of \
| | 605| 929k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 929k| * incorrect destructor function with the pointer */ \
| | 607| 929k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 929k]
| | ------------------
| | 608| 929k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 929k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 929k]
| | ------------------
------------------
1764| 929k| IGRAPH_CHECK(igraph_strvector_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 656| 929k| do { \
| | 657| 929k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 929k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 929k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 929k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 929k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 929k]
| | ------------------
------------------
1765| 1.85M| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 1.85M|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 929k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1765:16): [True: 929k, False: 929k]
------------------
1766| 929k| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 929k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 929k, False: 0]
| | ------------------
| | 406| 929k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1767| 929k| IGRAPH_CHECK(igraph_strvector_set(value, i, igraph_strvector_get(str, e)));
------------------
| | 656| 929k| do { \
| | 657| 929k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 929k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 929k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 929k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 929k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 929k]
| | ------------------
------------------
1768| 929k| }
1769| 929k| igraph_eit_destroy(&it);
1770| 929k| IGRAPH_FINALLY_CLEAN(1);
1771| 929k| }
1772| |
1773| 929k| return IGRAPH_SUCCESS;
1774| 929k|}
cattributes.c:igraph_i_cattribute_get_bool_edge_attr:
1779| 17.3k|) {
1780| 17.3k| igraph_i_cattributes_t *attr = graph->attr;
1781| 17.3k| igraph_attribute_record_list_t *eal = &attr->eal;
1782| 17.3k| igraph_attribute_record_t *rec;
1783| 17.3k| const igraph_vector_bool_t *log;
1784| |
1785| 17.3k| IGRAPH_CHECK(igraph_i_cattribute_find_or_return(eal, name, IGRAPH_ATTRIBUTE_BOOLEAN, &rec));
------------------
| | 656| 17.3k| do { \
| | 657| 17.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 13, False: 17.3k]
| | | | ------------------
| | ------------------
| | 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| 17.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.3k]
| | ------------------
------------------
1786| |
1787| 17.3k| log = rec->value.as_vector_bool;
1788| 17.3k| if (igraph_es_is_all(&es)) {
------------------
| Branch (1788:9): [True: 16, False: 17.3k]
------------------
1789| 16| IGRAPH_CHECK(igraph_vector_bool_append(value, log));
------------------
| | 656| 16| do { \
| | 657| 16| igraph_error_t igraph_i_ret = (expr); \
| | 658| 16| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 16| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 16]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16]
| | ------------------
------------------
1790| 17.3k| } else {
1791| 17.3k| igraph_eit_t it;
1792| 17.3k| igraph_int_t i = igraph_vector_bool_size(value);
1793| 17.3k| IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
------------------
| | 656| 17.3k| do { \
| | 657| 17.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.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| 17.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.3k]
| | ------------------
------------------
1794| 17.3k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 17.3k| do { \
| | 604| 17.3k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.3k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.3k| * incorrect destructor function with the pointer */ \
| | 607| 17.3k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.3k]
| | ------------------
| | 608| 17.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.3k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.3k]
| | ------------------
------------------
1795| 17.3k| IGRAPH_CHECK(igraph_vector_bool_resize(value, i + IGRAPH_EIT_SIZE(it)));
------------------
| | 656| 17.3k| do { \
| | 657| 17.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.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| 17.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.3k]
| | ------------------
------------------
1796| 34.6k| for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 371| 34.6k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
------------------
| | 359| 17.3k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (1796:16): [True: 17.3k, False: 17.3k]
------------------
1797| 17.3k| igraph_int_t e = IGRAPH_EIT_GET(it);
------------------
| | 405| 17.3k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 17.3k, False: 0]
| | ------------------
| | 406| 17.3k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1798| 17.3k| VECTOR(*value)[i] = VECTOR(*log)[e];
------------------
| | 60| 17.3k|#define VECTOR(v) ((v).stor_begin)
------------------
VECTOR(*value)[i] = VECTOR(*log)[e];
------------------
| | 60| 17.3k|#define VECTOR(v) ((v).stor_begin)
------------------
1799| 17.3k| }
1800| 17.3k| igraph_eit_destroy(&it);
1801| 17.3k| IGRAPH_FINALLY_CLEAN(1);
1802| 17.3k| }
1803| |
1804| 17.3k| return IGRAPH_SUCCESS;
1805| 17.3k|}
cattributes.c:igraph_i_cattribute_find:
69| 1.44M|) {
70| 1.44M| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name);
71| 1.44M| igraph_attribute_record_t *rec;
72| |
73| 1.44M| if (index >= 0) {
------------------
| Branch (73:9): [True: 1.41M, False: 30.0k]
------------------
74| 1.41M| rec = igraph_attribute_record_list_get_ptr(attrs, index);
75| 1.41M| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) {
------------------
| Branch (75:13): [True: 1.41M, False: 0]
| Branch (75:53): [True: 0, False: 0]
------------------
76| 1.41M| return rec;
77| 1.41M| }
78| 1.41M| }
79| |
80| 30.0k| return NULL;
81| 1.44M|}
cattributes.c:igraph_i_cattribute_find_or_create:
147| 30.0k|) {
148| 30.0k| igraph_attribute_record_t *rec;
149| |
150| 30.0k| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED);
151| 30.0k| if (rec) {
------------------
| Branch (151:9): [True: 0, False: 30.0k]
------------------
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| 30.0k| } else {
156| 30.0k| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(attrs, &rec));
------------------
| | 656| 30.0k| do { \
| | 657| 30.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 30.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 30.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 30.0k]
| | ------------------
------------------
157| 30.0k| IGRAPH_CHECK(igraph_attribute_record_set_name(rec, name));
------------------
| | 656| 30.0k| do { \
| | 657| 30.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 30.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 30.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 30.0k]
| | ------------------
------------------
158| 30.0k| IGRAPH_CHECK(igraph_attribute_record_set_type(rec, type));
------------------
| | 656| 30.0k| do { \
| | 657| 30.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 30.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 30.0k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 30.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 30.0k]
| | ------------------
------------------
159| 30.0k| }
160| |
161| 30.0k| if (length > 0 && igraph_attribute_record_size(rec) < length) {
------------------
| Branch (161:9): [True: 0, False: 30.0k]
| 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| 30.0k| if (ptr) {
------------------
| Branch (165:9): [True: 0, False: 30.0k]
------------------
166| 0| *ptr = rec;
167| 0| }
168| |
169| 30.0k| return IGRAPH_SUCCESS;
170| 30.0k|}
cattributes.c:igraph_i_cattribute_find_index:
49| 1.70M|) {
50| 1.70M| igraph_int_t n = igraph_attribute_record_list_size(attrs);
51| 3.09M| for (igraph_int_t i = 0; i < n; i++) {
------------------
| Branch (51:30): [True: 2.84M, False: 252k]
------------------
52| 2.84M| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrs, i);
53| 2.84M| if (!strcmp(rec->name, name)) {
------------------
| Branch (53:13): [True: 1.45M, False: 1.39M]
------------------
54| 1.45M| return i;
55| 1.45M| }
56| 2.84M| }
57| 252k| return -1;
58| 1.70M|}
igraph_vss_all:
115| 1.32k|igraph_vs_t igraph_vss_all(void) {
116| 1.32k| igraph_vs_t allvs;
117| 1.32k| allvs.type = IGRAPH_VS_ALL;
118| 1.32k| return allvs;
119| 1.32k|}
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| 18.4k| igraph_edgeorder_type_t order) {
922| 18.4k| switch (order) {
923| 11.3k| case IGRAPH_EDGEORDER_ID:
------------------
| Branch (923:5): [True: 11.3k, False: 7.15k]
------------------
924| 11.3k| es->type = IGRAPH_ES_ALL;
925| 11.3k| break;
926| 7.15k| case IGRAPH_EDGEORDER_FROM:
------------------
| Branch (926:5): [True: 7.15k, False: 11.3k]
------------------
927| 7.15k| es->type = IGRAPH_ES_ALLFROM;
928| 7.15k| break;
929| 0| case IGRAPH_EDGEORDER_TO:
------------------
| Branch (929:5): [True: 0, False: 18.4k]
------------------
930| 0| es->type = IGRAPH_ES_ALLTO;
931| 0| break;
932| 0| default:
------------------
| Branch (932:5): [True: 0, False: 18.4k]
------------------
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| 18.4k| }
936| 18.4k| return IGRAPH_SUCCESS;
937| 18.4k|}
igraph_ess_all:
953| 14.9k|igraph_es_t igraph_ess_all(igraph_edgeorder_type_t order) {
954| 14.9k| igraph_es_t es;
955| 14.9k| igraph_es_all(&es, order); /* cannot fail */
956| 14.9k| return es;
957| 14.9k|}
igraph_ess_1:
1058| 1.28M|igraph_es_t igraph_ess_1(igraph_int_t eid) {
1059| 1.28M| igraph_es_t es;
1060| 1.28M| es.type = IGRAPH_ES_1;
1061| 1.28M| es.data.eid = eid;
1062| 1.28M| return es;
1063| 1.28M|}
igraph_es_destroy:
1408| 3.57k|void igraph_es_destroy(igraph_es_t *es) {
1409| 3.57k| switch (es->type) {
1410| 3.57k| case IGRAPH_ES_ALL:
------------------
| Branch (1410:5): [True: 3.57k, False: 0]
------------------
1411| 3.57k| case IGRAPH_ES_ALLFROM:
------------------
| Branch (1411:5): [True: 0, False: 3.57k]
------------------
1412| 3.57k| case IGRAPH_ES_ALLTO:
------------------
| Branch (1412:5): [True: 0, False: 3.57k]
------------------
1413| 3.57k| case IGRAPH_ES_INCIDENT:
------------------
| Branch (1413:5): [True: 0, False: 3.57k]
------------------
1414| 3.57k| case IGRAPH_ES_NONE:
------------------
| Branch (1414:5): [True: 0, False: 3.57k]
------------------
1415| 3.57k| case IGRAPH_ES_1:
------------------
| Branch (1415:5): [True: 0, False: 3.57k]
------------------
1416| 3.57k| case IGRAPH_ES_VECTORPTR:
------------------
| Branch (1416:5): [True: 0, False: 3.57k]
------------------
1417| 3.57k| case IGRAPH_ES_RANGE:
------------------
| Branch (1417:5): [True: 0, False: 3.57k]
------------------
1418| 3.57k| case IGRAPH_ES_ALL_BETWEEN:
------------------
| Branch (1418:5): [True: 0, False: 3.57k]
------------------
1419| 3.57k| break;
1420| 0| case IGRAPH_ES_VECTOR:
------------------
| Branch (1420:5): [True: 0, False: 3.57k]
------------------
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.57k]
------------------
1425| 0| case IGRAPH_ES_PATH:
------------------
| Branch (1425:5): [True: 0, False: 3.57k]
------------------
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.57k]
------------------
1430| 0| break;
1431| 3.57k| }
1432| 3.57k|}
igraph_es_is_all:
1445| 1.28M|igraph_bool_t igraph_es_is_all(const igraph_es_t *es) {
1446| 1.28M| return es->type == IGRAPH_ES_ALL;
1447| 1.28M|}
igraph_eit_create:
1922| 1.30M|igraph_error_t igraph_eit_create(const igraph_t *graph, igraph_es_t es, igraph_eit_t *eit) {
1923| 1.30M| switch (es.type) {
1924| 10.7k| case IGRAPH_ES_ALL:
------------------
| Branch (1924:5): [True: 10.7k, False: 1.29M]
------------------
1925| 10.7k| eit->type = IGRAPH_EIT_RANGE;
1926| 10.7k| eit->pos = 0;
1927| 10.7k| eit->start = 0;
1928| 10.7k| eit->end = igraph_ecount(graph);
1929| 10.7k| break;
1930| 7.15k| case IGRAPH_ES_ALLFROM:
------------------
| Branch (1930:5): [True: 7.15k, False: 1.29M]
------------------
1931| 7.15k| IGRAPH_CHECK(igraph_i_eit_create_allfromto(graph, eit, IGRAPH_OUT));
------------------
| | 656| 7.15k| do { \
| | 657| 7.15k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.15k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 7.15k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.15k]
| | ------------------
------------------
1932| 7.15k| break;
1933| 7.15k| case IGRAPH_ES_ALLTO:
------------------
| Branch (1933:5): [True: 0, False: 1.30M]
------------------
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.30M]
------------------
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.30M]
------------------
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.28M| case IGRAPH_ES_1:
------------------
| Branch (1945:5): [True: 1.28M, False: 17.8k]
------------------
1946| 1.28M| eit->type = IGRAPH_EIT_RANGE;
1947| 1.28M| eit->pos = es.data.eid;
1948| 1.28M| eit->start = es.data.eid;
1949| 1.28M| eit->end = es.data.eid + 1;
1950| 1.28M| if (eit->pos >= igraph_ecount(graph)) {
------------------
| Branch (1950:13): [True: 0, False: 1.28M]
------------------
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.28M| break;
1954| 1.28M| case IGRAPH_ES_VECTOR:
------------------
| Branch (1954:5): [True: 0, False: 1.30M]
------------------
1955| 0| case IGRAPH_ES_VECTORPTR:
------------------
| Branch (1955:5): [True: 0, False: 1.30M]
------------------
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.30M]
------------------
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.30M]
------------------
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.30M]
------------------
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.30M]
------------------
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.30M]
------------------
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.30M| }
1995| 1.30M| return IGRAPH_SUCCESS;
1996| 1.30M|}
igraph_eit_destroy:
2008| 1.30M|void igraph_eit_destroy(const igraph_eit_t *eit) {
2009| 1.30M| switch (eit->type) {
2010| 1.29M| case IGRAPH_EIT_RANGE:
------------------
| Branch (2010:5): [True: 1.29M, False: 7.15k]
------------------
2011| 1.29M| case IGRAPH_EIT_VECTORPTR:
------------------
| Branch (2011:5): [True: 0, False: 1.30M]
------------------
2012| 1.29M| break;
2013| 7.15k| case IGRAPH_EIT_VECTOR:
------------------
| Branch (2013:5): [True: 7.15k, False: 1.29M]
------------------
2014| 7.15k| igraph_vector_int_destroy((igraph_vector_int_t*)eit->vec);
2015| 7.15k| igraph_free((igraph_vector_int_t*)eit->vec);
2016| 7.15k| break;
2017| 0| default:
------------------
| Branch (2017:5): [True: 0, False: 1.30M]
------------------
2018| | /* IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */
2019| 0| break;
2020| 1.30M| }
2021| 1.30M|}
iterators.c:igraph_i_eit_create_allfromto:
1696| 7.15k| igraph_neimode_t mode) {
1697| 7.15k| igraph_vector_int_t *vec;
1698| 7.15k| igraph_int_t no_of_nodes = igraph_vcount(graph);
1699| 7.15k| igraph_int_t no_of_edges = igraph_ecount(graph);
1700| |
1701| 7.15k| vec = IGRAPH_CALLOC(1, igraph_vector_int_t);
------------------
| | 33| 7.15k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 14.3k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 7.15k, Folded]
| | | | ------------------
| | ------------------
------------------
1702| 7.15k| IGRAPH_CHECK_OOM(vec, "Cannot create edge iterator.");
------------------
| | 709| 7.15k| do { \
| | 710| 7.15k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 7.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.15k]
| | | | ------------------
| | ------------------
| | 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.15k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 7.15k]
| | ------------------
------------------
1703| 7.15k| IGRAPH_FINALLY(igraph_free, vec);
------------------
| | 603| 7.15k| do { \
| | 604| 7.15k| /* the following branch makes the compiler check the compatibility of \
| | 605| 7.15k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 7.15k| * incorrect destructor function with the pointer */ \
| | 607| 7.15k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 7.15k]
| | ------------------
| | 608| 7.15k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 7.15k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 7.15k]
| | ------------------
------------------
1704| |
1705| 7.15k| IGRAPH_VECTOR_INT_INIT_FINALLY(vec, 0);
------------------
| | 119| 7.15k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 7.15k| do { \
| | | | 657| 7.15k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 7.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 7.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 7.15k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 7.15k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 7.15k]
| | | | ------------------
| | ------------------
| | 120| 7.15k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 7.15k| do { \
| | | | 604| 7.15k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 7.15k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 7.15k| * incorrect destructor function with the pointer */ \
| | | | 607| 7.15k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 7.15k]
| | | | ------------------
| | | | 608| 7.15k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 7.15k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 7.15k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 7.15k]
| | ------------------
------------------
1706| 7.15k| IGRAPH_CHECK(igraph_vector_int_reserve(vec, no_of_edges));
------------------
| | 656| 7.15k| do { \
| | 657| 7.15k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.15k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 7.15k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.15k]
| | ------------------
------------------
1707| |
1708| 7.15k| if (igraph_is_directed(graph)) {
------------------
| Branch (1708:9): [True: 268, False: 6.88k]
------------------
1709| 268| igraph_vector_int_t adj;
1710| 268| IGRAPH_VECTOR_INT_INIT_FINALLY(&adj, 0);
------------------
| | 119| 268| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 268| do { \
| | | | 657| 268| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 268| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 268| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 268]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 268| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 268]
| | | | ------------------
| | ------------------
| | 120| 268| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 268| do { \
| | | | 604| 268| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 268| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 268| * incorrect destructor function with the pointer */ \
| | | | 607| 268| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 268]
| | | | ------------------
| | | | 608| 268| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 268| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 268]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 268]
| | ------------------
------------------
1711| 2.47k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1711:34): [True: 2.20k, False: 268]
------------------
1712| 2.20k| IGRAPH_CHECK(igraph_incident(graph, &adj, i, mode, IGRAPH_LOOPS));
------------------
| | 656| 2.20k| do { \
| | 657| 2.20k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.20k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.20k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.20k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.20k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.20k]
| | ------------------
------------------
1713| 2.20k| igraph_vector_int_append(vec, &adj); /* reserved */
1714| 2.20k| }
1715| 268| igraph_vector_int_destroy(&adj);
1716| 268| IGRAPH_FINALLY_CLEAN(1);
1717| 6.88k| } else {
1718| 6.88k| igraph_vector_int_t adj;
1719| 6.88k| igraph_bool_t *added;
1720| 6.88k| IGRAPH_VECTOR_INT_INIT_FINALLY(&adj, 0);
------------------
| | 119| 6.88k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 6.88k| do { \
| | | | 657| 6.88k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 6.88k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 6.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 6.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| 6.88k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 6.88k]
| | | | ------------------
| | ------------------
| | 120| 6.88k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 6.88k| do { \
| | | | 604| 6.88k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 6.88k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 6.88k| * incorrect destructor function with the pointer */ \
| | | | 607| 6.88k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 6.88k]
| | | | ------------------
| | | | 608| 6.88k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 6.88k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 6.88k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 6.88k]
| | ------------------
------------------
1721| 6.88k| added = IGRAPH_CALLOC(no_of_edges, igraph_bool_t);
------------------
| | 33| 6.88k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 13.7k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 6.88k, False: 0]
| | | | | Branch (31:24): [True: 6.88k, False: 0]
| | | | | Branch (31:66): [True: 4.95k, False: 1.93k]
| | | | ------------------
| | ------------------
------------------
1722| 6.88k| IGRAPH_CHECK_OOM(added, "Cannot create edge iterator.");
------------------
| | 709| 6.88k| do { \
| | 710| 6.88k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 6.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 6.88k]
| | | | ------------------
| | ------------------
| | 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.88k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 6.88k]
| | ------------------
------------------
1723| 6.88k| IGRAPH_FINALLY(igraph_free, added);
------------------
| | 603| 6.88k| do { \
| | 604| 6.88k| /* the following branch makes the compiler check the compatibility of \
| | 605| 6.88k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 6.88k| * incorrect destructor function with the pointer */ \
| | 607| 6.88k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 6.88k]
| | ------------------
| | 608| 6.88k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 6.88k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 6.88k]
| | ------------------
------------------
1724| 71.1k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1724:34): [True: 64.2k, False: 6.88k]
------------------
1725| 64.2k| IGRAPH_CHECK(igraph_incident(graph, &adj, i, IGRAPH_ALL, IGRAPH_LOOPS));
------------------
| | 656| 64.2k| do { \
| | 657| 64.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 64.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 64.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 64.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| 64.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 64.2k]
| | ------------------
------------------
1726| 64.2k| const igraph_int_t length = igraph_vector_int_size(&adj);
1727| 812k| for (igraph_int_t j = 0; j < length; j++) {
------------------
| Branch (1727:38): [True: 748k, False: 64.2k]
------------------
1728| 748k| if (!added[ VECTOR(adj)[j] ]) {
------------------
| | 60| 748k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1728:21): [True: 374k, False: 374k]
------------------
1729| 374k| igraph_vector_int_push_back(vec, VECTOR(adj)[j]); /* reserved */
------------------
| | 60| 374k|#define VECTOR(v) ((v).stor_begin)
------------------
1730| 374k| added[ VECTOR(adj)[j] ] = true;
------------------
| | 60| 374k|#define VECTOR(v) ((v).stor_begin)
------------------
1731| 374k| }
1732| 748k| }
1733| 64.2k| }
1734| 6.88k| igraph_vector_int_destroy(&adj);
1735| 6.88k| IGRAPH_FREE(added);
------------------
| | 36| 6.88k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1736| 6.88k| IGRAPH_FINALLY_CLEAN(2);
1737| 6.88k| }
1738| |
1739| 7.15k| eit->type = IGRAPH_EIT_VECTOR;
1740| 7.15k| eit->pos = 0;
1741| 7.15k| eit->start = 0;
1742| 7.15k| eit->vec = vec;
1743| 7.15k| eit->end = igraph_vector_int_size(eit->vec);
1744| |
1745| 7.15k| IGRAPH_FINALLY_CLEAN(2);
1746| 7.15k| return IGRAPH_SUCCESS;
1747| 7.15k|}
igraph_empty:
64| 6.90k|igraph_error_t igraph_empty(igraph_t *graph, igraph_int_t n, igraph_bool_t directed) {
65| 6.90k| return igraph_empty_attrs(graph, n, directed, 0);
66| 6.90k|}
igraph_edge:
132| 1.39M|) {
133| |
134| 1.39M| if (eid < 0 || eid >= igraph_ecount(graph)) {
------------------
| Branch (134:9): [True: 0, False: 1.39M]
| Branch (134:20): [True: 0, False: 1.39M]
------------------
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.39M| if (igraph_is_directed(graph)) {
------------------
| Branch (138:9): [True: 467k, False: 930k]
------------------
139| 467k| *from = IGRAPH_FROM(graph, eid);
------------------
| | 115| 467k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 467k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
140| 467k| *to = IGRAPH_TO(graph, eid);
------------------
| | 128| 467k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 467k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
141| 930k| } else {
142| 930k| *from = IGRAPH_TO(graph, eid);
------------------
| | 128| 930k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 930k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
143| 930k| *to = IGRAPH_FROM(graph, eid);
------------------
| | 115| 930k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 930k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
144| 930k| }
145| |
146| 1.39M| return IGRAPH_SUCCESS;
147| 1.39M|}
igraph_empty_attrs:
102| 17.5k|) {
103| |
104| 17.5k| if (n < 0) {
------------------
| Branch (104:9): [True: 0, False: 17.5k]
------------------
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| 17.5k| memset(graph, 0, sizeof(igraph_t));
109| |
110| 17.5k| graph->n = 0;
111| 17.5k| graph->directed = directed;
112| 17.5k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0);
------------------
| | 119| 17.5k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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: 0, False: 17.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| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | 120| 17.5k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 17.5k| do { \
| | | | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | | | 607| 17.5k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 17.5k]
| | | | ------------------
| | | | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 17.5k]
| | ------------------
------------------
113| 17.5k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0);
------------------
| | 119| 17.5k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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: 0, False: 17.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| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | 120| 17.5k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 17.5k| do { \
| | | | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | | | 607| 17.5k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 17.5k]
| | | | ------------------
| | | | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 17.5k]
| | ------------------
------------------
114| 17.5k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0);
------------------
| | 119| 17.5k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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: 0, False: 17.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| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | 120| 17.5k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 17.5k| do { \
| | | | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | | | 607| 17.5k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 17.5k]
| | | | ------------------
| | | | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 17.5k]
| | ------------------
------------------
115| 17.5k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0);
------------------
| | 119| 17.5k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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: 0, False: 17.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| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | 120| 17.5k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 17.5k| do { \
| | | | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | | | 607| 17.5k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 17.5k]
| | | | ------------------
| | | | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 17.5k]
| | ------------------
------------------
116| 17.5k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1);
------------------
| | 119| 17.5k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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: 0, False: 17.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| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | 120| 17.5k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 17.5k| do { \
| | | | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | | | 607| 17.5k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 17.5k]
| | | | ------------------
| | | | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 17.5k]
| | ------------------
------------------
117| 17.5k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1);
------------------
| | 119| 17.5k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 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: 0, False: 17.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| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | 120| 17.5k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 17.5k| do { \
| | | | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | | | 607| 17.5k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 17.5k]
| | | | ------------------
| | | | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 17.5k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 17.5k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 17.5k]
| | ------------------
------------------
118| |
119| | /* init cache */
120| 17.5k| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t);
------------------
| | 33| 17.5k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 35.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: 17.5k, Folded]
| | | | ------------------
| | ------------------
------------------
121| 17.5k| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph.");
------------------
| | 709| 17.5k| do { \
| | 710| 17.5k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 17.5k]
| | ------------------
------------------
122| 17.5k| IGRAPH_FINALLY(igraph_free, graph->cache);
------------------
| | 603| 17.5k| do { \
| | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | 607| 17.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.5k]
| | ------------------
| | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.5k]
| | ------------------
------------------
123| 17.5k| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache));
------------------
| | 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: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
124| 17.5k| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache);
------------------
| | 603| 17.5k| do { \
| | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | 607| 17.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.5k]
| | ------------------
| | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.5k]
| | ------------------
------------------
125| |
126| 17.5k| VECTOR(graph->os)[0] = 0;
------------------
| | 60| 17.5k|#define VECTOR(v) ((v).stor_begin)
------------------
127| 17.5k| VECTOR(graph->is)[0] = 0;
------------------
| | 60| 17.5k|#define VECTOR(v) ((v).stor_begin)
------------------
128| |
129| | /* init attributes */
130| 17.5k| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr));
------------------
| | 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: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
131| |
132| | /* add the vertices */
133| 17.5k| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0));
------------------
| | 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: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
134| |
135| 17.5k| IGRAPH_FINALLY_CLEAN(8);
136| 17.5k| return IGRAPH_SUCCESS;
137| 17.5k|}
igraph_destroy:
155| 17.5k|void igraph_destroy(igraph_t *graph) {
156| 17.5k| igraph_i_attribute_destroy(graph);
157| |
158| 17.5k| igraph_i_property_cache_destroy(graph->cache);
159| 17.5k| IGRAPH_FREE(graph->cache);
------------------
| | 36| 17.5k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
160| |
161| 17.5k| igraph_vector_int_destroy(&graph->from);
162| 17.5k| igraph_vector_int_destroy(&graph->to);
163| 17.5k| igraph_vector_int_destroy(&graph->oi);
164| 17.5k| igraph_vector_int_destroy(&graph->ii);
165| 17.5k| igraph_vector_int_destroy(&graph->os);
166| 17.5k| igraph_vector_int_destroy(&graph->is);
167| 17.5k|}
igraph_add_edges:
257| 17.5k|) {
258| 17.5k| igraph_int_t no_of_edges = igraph_vector_int_size(&graph->from);
259| 17.5k| igraph_int_t edges_to_add = igraph_vector_int_size(edges) / 2;
260| 17.5k| igraph_int_t new_no_of_edges;
261| 17.5k| igraph_int_t i = 0;
262| 17.5k| igraph_vector_int_t newoi, newii;
263| 17.5k| igraph_bool_t directed = igraph_is_directed(graph);
264| |
265| 17.5k| if (igraph_vector_int_size(edges) % 2 != 0) {
------------------
| Branch (265:9): [True: 0, False: 17.5k]
------------------
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| 17.5k| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) {
------------------
| Branch (268:9): [True: 0, False: 17.5k]
------------------
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| 17.5k| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges);
------------------
| | 47| 17.5k| do { \
| | 48| 17.5k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 17.5k| igraph_int_t _safe_sum; \
| | 50| 17.5k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 17.5k]
| | ------------------
| | 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| 17.5k| *(res) = _safe_sum; \
| | 54| 17.5k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 17.5k]
| | ------------------
------------------
274| 17.5k| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) {
------------------
| | 118| 17.5k|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2)
| | ------------------
| | | | 72| 17.5k|# define IGRAPH_INTEGER_MAX INT64_MAX
| | ------------------
------------------
| Branch (274:9): [True: 0, False: 17.5k]
------------------
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| 17.5k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add));
------------------
| | 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: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
279| 17.5k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add));
------------------
| | 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: 0, False: 17.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| 17.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.5k]
| | ------------------
------------------
280| |
281| 1.41M| while (i < edges_to_add * 2) {
------------------
| Branch (281:12): [True: 1.39M, False: 17.5k]
------------------
282| 1.39M| if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) {
------------------
| | 60| 561k|#define VECTOR(v) ((v).stor_begin)
------------------
if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) {
------------------
| | 60| 561k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (282:13): [True: 837k, False: 561k]
| Branch (282:25): [True: 197k, False: 363k]
------------------
283| 1.03M| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 1.03M|#define VECTOR(v) ((v).stor_begin)
------------------
284| 1.03M| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 1.03M|#define VECTOR(v) ((v).stor_begin)
------------------
285| 1.03M| } else {
286| 363k| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 363k|#define VECTOR(v) ((v).stor_begin)
------------------
287| 363k| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */
------------------
| | 60| 363k|#define VECTOR(v) ((v).stor_begin)
------------------
288| 363k| }
289| 1.39M| }
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| 17.5k|#define CHECK_ERR(expr) \
299| 17.5k| do { \
300| 17.5k| igraph_error_t err = (expr); \
301| 17.5k| if (err != IGRAPH_SUCCESS) { \
302| 17.5k| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \
303| 17.5k| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \
304| 17.5k| IGRAPH_FINALLY_EXIT(); \
305| 17.5k| IGRAPH_ERROR("Cannot add edges.", err); \
306| 17.5k| } \
307| 17.5k| } while (0)
308| |
309| | /* oi & ii */
310| 17.5k| IGRAPH_FINALLY_ENTER();
311| 17.5k| {
312| 17.5k| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges));
------------------
| | 299| 17.5k| do { \
| | 300| 17.5k| igraph_error_t err = (expr); \
| | 301| 17.5k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 17.5k]
| | ------------------
| | 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| 17.5k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 17.5k]
| | ------------------
------------------
313| 17.5k| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi);
------------------
| | 603| 17.5k| do { \
| | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | 607| 17.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.5k]
| | ------------------
| | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.5k]
| | ------------------
------------------
314| 17.5k| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges));
------------------
| | 299| 17.5k| do { \
| | 300| 17.5k| igraph_error_t err = (expr); \
| | 301| 17.5k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 17.5k]
| | ------------------
| | 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| 17.5k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 17.5k]
| | ------------------
------------------
315| 17.5k| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii);
------------------
| | 603| 17.5k| do { \
| | 604| 17.5k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.5k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.5k| * incorrect destructor function with the pointer */ \
| | 607| 17.5k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.5k]
| | ------------------
| | 608| 17.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.5k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.5k]
| | ------------------
------------------
316| 17.5k| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n));
------------------
| | 299| 17.5k| do { \
| | 300| 17.5k| igraph_error_t err = (expr); \
| | 301| 17.5k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 17.5k]
| | ------------------
| | 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| 17.5k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 17.5k]
| | ------------------
------------------
317| 17.5k| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n));
------------------
| | 299| 17.5k| do { \
| | 300| 17.5k| igraph_error_t err = (expr); \
| | 301| 17.5k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 17.5k]
| | ------------------
| | 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| 17.5k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 17.5k]
| | ------------------
------------------
318| |
319| | /* Attributes */
320| 17.5k| if (graph->attr) {
------------------
| Branch (320:13): [True: 17.5k, False: 0]
------------------
321| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */
322| 17.5k| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr));
------------------
| | 299| 17.5k| do { \
| | 300| 17.5k| igraph_error_t err = (expr); \
| | 301| 17.5k| if (err != IGRAPH_SUCCESS) { \
| | ------------------
| | | Branch (301:13): [True: 0, False: 17.5k]
| | ------------------
| | 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| 17.5k| } while (0)
| | ------------------
| | | Branch (307:14): [Folded, False: 17.5k]
| | ------------------
------------------
323| 17.5k| }
324| |
325| | /* os & is, its length does not change, error safe */
326| 17.5k| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n);
327| 17.5k| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n);
328| |
329| | /* everything went fine */
330| 17.5k| igraph_vector_int_destroy(&graph->oi);
331| 17.5k| igraph_vector_int_destroy(&graph->ii);
332| 17.5k| IGRAPH_FINALLY_CLEAN(2);
333| |
334| 17.5k| graph->oi = newoi;
335| 17.5k| graph->ii = newii;
336| 17.5k| }
337| 0| IGRAPH_FINALLY_EXIT();
338| |
339| 17.5k|#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| 17.5k| igraph_i_property_cache_invalidate_conditionally(
354| 17.5k| graph,
355| 17.5k| /* keep_always = */ 0,
356| | /* keep_when_false = */
357| 17.5k| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST),
358| | /* keep_when_true = */
359| 17.5k| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) |
360| 17.5k| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) |
361| 17.5k| (1 << IGRAPH_PROP_HAS_LOOP) |
362| 17.5k| (1 << IGRAPH_PROP_HAS_MULTI) |
363| 17.5k| (1 << IGRAPH_PROP_HAS_MUTUAL)
364| 17.5k| );
365| |
366| 17.5k| return IGRAPH_SUCCESS;
367| 17.5k|}
igraph_add_vertices:
391| 35.1k|) {
392| 35.1k| igraph_int_t ec = igraph_ecount(graph);
393| 35.1k| igraph_int_t vc = igraph_vcount(graph);
394| 35.1k| igraph_int_t new_vc;
395| 35.1k| igraph_int_t i;
396| |
397| 35.1k| if (nv < 0) {
------------------
| Branch (397:9): [True: 0, False: 35.1k]
------------------
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| 35.1k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc);
------------------
| | 47| 35.1k| do { \
| | 48| 35.1k| igraph_int_t _safe_a = (a), _safe_b = (b); \
| | 49| 35.1k| igraph_int_t _safe_sum; \
| | 50| 35.1k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \
| | ------------------
| | | Branch (50:13): [True: 0, False: 35.1k]
| | ------------------
| | 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| 35.1k| *(res) = _safe_sum; \
| | 54| 35.1k| } while (0)
| | ------------------
| | | Branch (54:14): [Folded, False: 35.1k]
| | ------------------
------------------
402| 35.1k| if (new_vc > IGRAPH_VCOUNT_MAX) {
------------------
| | 100| 35.1k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1)
| | ------------------
| | | | 72| 35.1k|# define IGRAPH_INTEGER_MAX INT64_MAX
| | ------------------
------------------
| Branch (402:9): [True: 0, False: 35.1k]
------------------
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| 35.1k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1));
------------------
| | 656| 35.1k| do { \
| | 657| 35.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 35.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 35.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 35.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| 35.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 35.1k]
| | ------------------
------------------
407| 35.1k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1));
------------------
| | 656| 35.1k| do { \
| | 657| 35.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 35.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 35.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 35.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| 35.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 35.1k]
| | ------------------
------------------
408| |
409| 35.1k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */
410| 35.1k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */
411| 186k| for (i = graph->n + 1; i < new_vc + 1; i++) {
------------------
| Branch (411:28): [True: 151k, False: 35.1k]
------------------
412| 151k| VECTOR(graph->os)[i] = ec;
------------------
| | 60| 151k|#define VECTOR(v) ((v).stor_begin)
------------------
413| 151k| VECTOR(graph->is)[i] = ec;
------------------
| | 60| 151k|#define VECTOR(v) ((v).stor_begin)
------------------
414| 151k| }
415| |
416| 35.1k| 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| 35.1k| if (graph->attr) {
------------------
| Branch (422:9): [True: 35.1k, False: 0]
------------------
423| 35.1k| igraph_error_t err;
424| 35.1k| IGRAPH_FINALLY_ENTER();
425| 35.1k| err = igraph_i_attribute_add_vertices(graph, nv, attr);
426| 35.1k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (426:13): [True: 0, False: 35.1k]
------------------
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| 35.1k| IGRAPH_FINALLY_EXIT();
433| 35.1k| if (err != IGRAPH_SUCCESS) {
------------------
| Branch (433:13): [True: 0, False: 35.1k]
------------------
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| 35.1k| }
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| 35.1k| igraph_i_property_cache_invalidate_conditionally(
458| 35.1k| graph,
459| | /* keep_always = */
460| 35.1k| (1 << IGRAPH_PROP_HAS_LOOP) |
461| 35.1k| (1 << IGRAPH_PROP_HAS_MULTI) |
462| 35.1k| (1 << IGRAPH_PROP_HAS_MUTUAL) |
463| 35.1k| (1 << IGRAPH_PROP_IS_DAG) |
464| 35.1k| (1 << IGRAPH_PROP_IS_FOREST),
465| | /* keep_when_false = */
466| 35.1k| igraph_vcount(graph) >= 2 ? (
------------------
| Branch (466:9): [True: 12.0k, False: 23.1k]
------------------
467| 12.0k| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) |
468| 12.0k| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED)
469| 23.1k| ) : 0,
470| | /* keep_when_true = */
471| 35.1k| 0
472| 35.1k| );
473| |
474| 35.1k| return IGRAPH_SUCCESS;
475| 35.1k|}
igraph_vcount:
829| 622k|igraph_int_t igraph_vcount(const igraph_t *graph) {
830| 622k| return graph->n;
831| 622k|}
igraph_ecount:
843| 2.76M|igraph_int_t igraph_ecount(const igraph_t *graph) {
844| 2.76M| return igraph_vector_int_size(&graph->from);
845| 2.76M|}
igraph_is_directed:
1133| 1.78M|igraph_bool_t igraph_is_directed(const igraph_t *graph) {
1134| 1.78M| return graph->directed;
1135| 1.78M|}
igraph_get_eid:
1524| 279k| igraph_bool_t directed, igraph_bool_t error) {
1525| |
1526| 279k| igraph_int_t no_of_nodes = igraph_vcount(graph);
1527| |
1528| 279k| if (from < 0 || to < 0 || from >= no_of_nodes || to >= no_of_nodes) {
------------------
| Branch (1528:9): [True: 0, False: 279k]
| Branch (1528:21): [True: 0, False: 279k]
| Branch (1528:31): [True: 0, False: 279k]
| Branch (1528:54): [True: 0, False: 279k]
------------------
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| 279k| *eid = -1;
1533| 279k| if (igraph_is_directed(graph)) {
------------------
| Branch (1533:9): [True: 93.4k, False: 186k]
------------------
1534| |
1535| | /* Directed graph */
1536| 93.4k| FIND_DIRECTED_EDGE(graph, from, to, eid);
------------------
| | 1469| 93.4k| do { \
| | 1470| 93.4k| igraph_int_t start = VECTOR(graph->os)[xfrom]; \
| | ------------------
| | | | 60| 93.4k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1471| 93.4k| igraph_int_t end = VECTOR(graph->os)[xfrom+1]; \
| | ------------------
| | | | 60| 93.4k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1472| 93.4k| igraph_int_t N = end; \
| | 1473| 93.4k| igraph_int_t start2 = VECTOR(graph->is)[xto]; \
| | ------------------
| | | | 60| 93.4k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1474| 93.4k| igraph_int_t end2 = VECTOR(graph->is)[xto+1]; \
| | ------------------
| | | | 60| 93.4k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1475| 93.4k| igraph_int_t N2 = end2; \
| | 1476| 93.4k| igraph_int_t *nullpointer = NULL; \
| | 1477| 93.4k| if (end-start < end2-start2) { \
| | ------------------
| | | Branch (1477:13): [True: 37.5k, False: 55.9k]
| | ------------------
| | 1478| 37.5k| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \
| | ------------------
| | | | 1449| 37.5k| do { \
| | | | 1450| 203k| while ((start) < (end)) { \
| | | | ------------------
| | | | | Branch (1450:16): [True: 166k, False: 37.5k]
| | | | ------------------
| | | | 1451| 166k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | 1452| 166k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | ------------------
| | | | | | 60| 166k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1453| 166k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | ------------------
| | | | | | 60| 166k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1453:17): [True: 43.8k, False: 122k]
| | | | ------------------
| | | | 1454| 43.8k| (start) = mid+1; \
| | | | 1455| 122k| } else { \
| | | | 1456| 122k| (end) = mid; \
| | | | 1457| 122k| } \
| | | | 1458| 166k| } \
| | | | 1459| 37.5k| if ((start) < (N)) { \
| | | | ------------------
| | | | | Branch (1459:13): [True: 19.3k, False: 18.1k]
| | | | ------------------
| | | | 1460| 19.3k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | ------------------
| | | | | | 60| 19.3k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1461| 19.3k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | ------------------
| | | | | | 60| 19.3k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1461:17): [True: 9.98k, False: 9.39k]
| | | | ------------------
| | | | 1462| 9.98k| *(result) = e; \
| | | | 1463| 9.98k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | ------------------
| | | | | Branch (1463:21): [True: 0, False: 9.98k]
| | | | ------------------
| | | | 1464| 9.98k| } \
| | | | 1465| 19.3k| } \
| | | | 1466| 37.5k| } while (0)
| | | | ------------------
| | | | | Branch (1466:14): [Folded, False: 37.5k]
| | | | ------------------
| | ------------------
| | 1479| 55.9k| } else { \
| | 1480| 55.9k| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \
| | ------------------
| | | | 1449| 55.9k| do { \
| | | | 1450| 518k| while ((start) < (end)) { \
| | | | ------------------
| | | | | Branch (1450:16): [True: 462k, False: 55.9k]
| | | | ------------------
| | | | 1451| 462k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | 1452| 462k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | ------------------
| | | | | | 60| 462k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1453| 462k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | ------------------
| | | | | | 60| 462k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1453:17): [True: 29.8k, False: 432k]
| | | | ------------------
| | | | 1454| 29.8k| (start) = mid+1; \
| | | | 1455| 432k| } else { \
| | | | 1456| 432k| (end) = mid; \
| | | | 1457| 432k| } \
| | | | 1458| 462k| } \
| | | | 1459| 55.9k| if ((start) < (N)) { \
| | | | ------------------
| | | | | Branch (1459:13): [True: 52.4k, False: 3.55k]
| | | | ------------------
| | | | 1460| 52.4k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | ------------------
| | | | | | 60| 52.4k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1461| 52.4k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | ------------------
| | | | | | 60| 52.4k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | | Branch (1461:17): [True: 20.8k, False: 31.5k]
| | | | ------------------
| | | | 1462| 20.8k| *(result) = e; \
| | | | 1463| 20.8k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | ------------------
| | | | | Branch (1463:21): [True: 0, False: 20.8k]
| | | | ------------------
| | | | 1464| 20.8k| } \
| | | | 1465| 52.4k| } \
| | | | 1466| 55.9k| } while (0)
| | | | ------------------
| | | | | Branch (1466:14): [Folded, False: 55.9k]
| | | | ------------------
| | ------------------
| | 1481| 55.9k| } \
| | 1482| 93.4k| } while (0)
| | ------------------
| | | Branch (1482:14): [Folded, False: 93.4k]
| | ------------------
------------------
1537| 93.4k| if (!directed && *eid < 0) {
------------------
| Branch (1537:13): [True: 0, False: 93.4k]
| 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| 186k| } else {
1542| |
1543| | /* Undirected graph, they only have one mode */
1544| 186k| FIND_UNDIRECTED_EDGE(graph, from, to, eid);
------------------
| | 1485| 186k| do { \
| | 1486| 186k| igraph_int_t xfrom1 = from > to ? from : to; \
| | ------------------
| | | Branch (1486:31): [True: 183k, False: 2.24k]
| | ------------------
| | 1487| 186k| igraph_int_t xto1 = from > to ? to : from; \
| | ------------------
| | | Branch (1487:29): [True: 183k, False: 2.24k]
| | ------------------
| | 1488| 186k| FIND_DIRECTED_EDGE(graph, xfrom1, xto1, eid); \
| | ------------------
| | | | 1469| 186k| do { \
| | | | 1470| 186k| igraph_int_t start = VECTOR(graph->os)[xfrom]; \
| | | | ------------------
| | | | | | 60| 186k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1471| 186k| igraph_int_t end = VECTOR(graph->os)[xfrom+1]; \
| | | | ------------------
| | | | | | 60| 186k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1472| 186k| igraph_int_t N = end; \
| | | | 1473| 186k| igraph_int_t start2 = VECTOR(graph->is)[xto]; \
| | | | ------------------
| | | | | | 60| 186k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1474| 186k| igraph_int_t end2 = VECTOR(graph->is)[xto+1]; \
| | | | ------------------
| | | | | | 60| 186k|#define VECTOR(v) ((v).stor_begin)
| | | | ------------------
| | | | 1475| 186k| igraph_int_t N2 = end2; \
| | | | 1476| 186k| igraph_int_t *nullpointer = NULL; \
| | | | 1477| 186k| if (end-start < end2-start2) { \
| | | | ------------------
| | | | | Branch (1477:13): [True: 163k, False: 22.3k]
| | | | ------------------
| | | | 1478| 163k| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \
| | | | ------------------
| | | | | | 1449| 163k| do { \
| | | | | | 1450| 1.71M| while ((start) < (end)) { \
| | | | | | ------------------
| | | | | | | Branch (1450:16): [True: 1.54M, False: 163k]
| | | | | | ------------------
| | | | | | 1451| 1.54M| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | | | 1452| 1.54M| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | | | ------------------
| | | | | | | | 60| 1.54M|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1453| 1.54M| if (VECTOR((edgelist))[e] < (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 1.54M|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1453:17): [True: 22.9k, False: 1.52M]
| | | | | | ------------------
| | | | | | 1454| 22.9k| (start) = mid+1; \
| | | | | | 1455| 1.52M| } else { \
| | | | | | 1456| 1.52M| (end) = mid; \
| | | | | | 1457| 1.52M| } \
| | | | | | 1458| 1.54M| } \
| | | | | | 1459| 163k| if ((start) < (N)) { \
| | | | | | ------------------
| | | | | | | Branch (1459:13): [True: 163k, False: 0]
| | | | | | ------------------
| | | | | | 1460| 163k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | | | ------------------
| | | | | | | | 60| 163k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1461| 163k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 163k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1461:17): [True: 163k, False: 0]
| | | | | | ------------------
| | | | | | 1462| 163k| *(result) = e; \
| | | | | | 1463| 163k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | | | ------------------
| | | | | | | Branch (1463:21): [True: 0, False: 163k]
| | | | | | ------------------
| | | | | | 1464| 163k| } \
| | | | | | 1465| 163k| } \
| | | | | | 1466| 163k| } while (0)
| | | | | | ------------------
| | | | | | | Branch (1466:14): [Folded, False: 163k]
| | | | | | ------------------
| | | | ------------------
| | | | 1479| 163k| } else { \
| | | | 1480| 22.3k| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \
| | | | ------------------
| | | | | | 1449| 22.3k| do { \
| | | | | | 1450| 111k| while ((start) < (end)) { \
| | | | | | ------------------
| | | | | | | Branch (1450:16): [True: 88.8k, False: 22.3k]
| | | | | | ------------------
| | | | | | 1451| 88.8k| igraph_int_t mid =(start)+((end)-(start))/2; \
| | | | | | 1452| 88.8k| igraph_int_t e = VECTOR((iindex))[mid]; \
| | | | | | ------------------
| | | | | | | | 60| 88.8k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1453| 88.8k| if (VECTOR((edgelist))[e] < (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 88.8k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1453:17): [True: 5.76k, False: 83.0k]
| | | | | | ------------------
| | | | | | 1454| 5.76k| (start) = mid+1; \
| | | | | | 1455| 83.0k| } else { \
| | | | | | 1456| 83.0k| (end) = mid; \
| | | | | | 1457| 83.0k| } \
| | | | | | 1458| 88.8k| } \
| | | | | | 1459| 22.3k| if ((start) < (N)) { \
| | | | | | ------------------
| | | | | | | Branch (1459:13): [True: 22.3k, False: 0]
| | | | | | ------------------
| | | | | | 1460| 22.3k| igraph_int_t e = VECTOR((iindex))[(start)]; \
| | | | | | ------------------
| | | | | | | | 60| 22.3k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | 1461| 22.3k| if (VECTOR((edgelist))[e] == (value)) { \
| | | | | | ------------------
| | | | | | | | 60| 22.3k|#define VECTOR(v) ((v).stor_begin)
| | | | | | ------------------
| | | | | | | Branch (1461:17): [True: 22.3k, False: 0]
| | | | | | ------------------
| | | | | | 1462| 22.3k| *(result) = e; \
| | | | | | 1463| 22.3k| if (result_pos != 0) { *(result_pos) = start; } \
| | | | | | ------------------
| | | | | | | Branch (1463:21): [True: 0, False: 22.3k]
| | | | | | ------------------
| | | | | | 1464| 22.3k| } \
| | | | | | 1465| 22.3k| } \
| | | | | | 1466| 22.3k| } while (0)
| | | | | | ------------------
| | | | | | | Branch (1466:14): [Folded, False: 22.3k]
| | | | | | ------------------
| | | | ------------------
| | | | 1481| 22.3k| } \
| | | | 1482| 186k| } while (0)
| | | | ------------------
| | | | | Branch (1482:14): [Folded, False: 186k]
| | | | ------------------
| | ------------------
| | 1489| 186k| } while (0)
| | ------------------
| | | Branch (1489:14): [Folded, False: 186k]
| | ------------------
------------------
1545| |
1546| 186k| }
1547| |
1548| 279k| if (*eid < 0) {
------------------
| Branch (1548:9): [True: 62.6k, False: 217k]
------------------
1549| 62.6k| if (error) {
------------------
| Branch (1549:13): [True: 0, False: 62.6k]
------------------
1550| 0| IGRAPH_ERROR("Cannot get edge ID, no such edge.", IGRAPH_EINVAL);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1551| 0| }
1552| 62.6k| }
1553| |
1554| 279k| return IGRAPH_SUCCESS;
1555| 279k|}
igraph_incident:
1778| 66.4k|) {
1779| 66.4k| igraph_int_t length = 0, idx = 0;
1780| 66.4k| igraph_int_t i, j;
1781| 66.4k| igraph_int_t node = pnode;
1782| 66.4k| igraph_bool_t directed = igraph_is_directed(graph);
1783| |
1784| 66.4k| if (node < 0 || node > igraph_vcount(graph) - 1) {
------------------
| Branch (1784:9): [True: 0, False: 66.4k]
| Branch (1784:21): [True: 0, False: 66.4k]
------------------
1785| 0| IGRAPH_ERRORF("Vertex %" IGRAPH_PRId " is not in the graph.", IGRAPH_EINVVID, node);
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
1786| 0| }
1787| 66.4k| if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
------------------
| Branch (1787:9): [True: 64.2k, False: 2.20k]
| Branch (1787:31): [True: 64.2k, False: 0]
------------------
1788| 64.2k| mode != IGRAPH_ALL) {
------------------
| Branch (1788:9): [True: 0, False: 64.2k]
------------------
1789| 0| IGRAPH_ERROR("Mode should be either IGRAPH_OUT, IGRAPH_IN or IGRAPH_ALL.", IGRAPH_EINVMODE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1790| 0| }
1791| |
1792| 66.4k| if (!directed) {
------------------
| Branch (1792:9): [True: 64.2k, False: 2.20k]
------------------
1793| 64.2k| mode = IGRAPH_ALL;
1794| 64.2k| }
1795| |
1796| 66.4k| if (mode != IGRAPH_ALL && loops == IGRAPH_LOOPS_TWICE) {
------------------
| Branch (1796:9): [True: 2.20k, False: 64.2k]
| Branch (1796:31): [True: 2.20k, 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.20k| loops = IGRAPH_LOOPS_ONCE;
1802| 2.20k| }
1803| |
1804| | /* Calculate needed space first & allocate it */
1805| | /* Note that 'mode' is treated as a bit field here; it's okay because
1806| | * IGRAPH_ALL = IGRAPH_IN | IGRAPH_OUT, bit-wise */
1807| 66.4k| if (mode & IGRAPH_OUT) {
------------------
| Branch (1807:9): [True: 66.4k, False: 0]
------------------
1808| 66.4k| length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]);
------------------
| | 60| 66.4k|#define VECTOR(v) ((v).stor_begin)
------------------
length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]);
------------------
| | 60| 66.4k|#define VECTOR(v) ((v).stor_begin)
------------------
1809| 66.4k| }
1810| 66.4k| if (mode & IGRAPH_IN) {
------------------
| Branch (1810:9): [True: 64.2k, False: 2.20k]
------------------
1811| 64.2k| length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]);
------------------
| | 60| 64.2k|#define VECTOR(v) ((v).stor_begin)
------------------
length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]);
------------------
| | 60| 64.2k|#define VECTOR(v) ((v).stor_begin)
------------------
1812| 64.2k| }
1813| |
1814| 66.4k| IGRAPH_CHECK(igraph_vector_int_resize(eids, length));
------------------
| | 656| 66.4k| do { \
| | 657| 66.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 66.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 66.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.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| 66.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 66.4k]
| | ------------------
------------------
1815| |
1816| | /* The loops below produce an ordering what is consistent with the
1817| | * ordering returned by igraph_neighbors(), and this should be preserved.
1818| | * We are dealing with two sorted lists; one for the successors and one
1819| | * for the predecessors. If we have requested only one of them, we have
1820| | * an easy job. If we have requested both, we need to merge the two lists
1821| | * to ensure that the output is sorted by the vertex IDs of the "other"
1822| | * endpoint of the affected edges */
1823| 66.4k| if (!directed || mode != IGRAPH_ALL) {
------------------
| Branch (1823:9): [True: 64.2k, False: 2.20k]
| Branch (1823:22): [True: 2.20k, False: 0]
------------------
1824| | /* We did not ask for both directions; this is the easy case */
1825| |
1826| 66.4k| if (mode & IGRAPH_OUT) {
------------------
| Branch (1826:13): [True: 66.4k, False: 0]
------------------
1827| 66.4k| j = VECTOR(graph->os)[node + 1];
------------------
| | 60| 66.4k|#define VECTOR(v) ((v).stor_begin)
------------------
1828| 627k| for (i = VECTOR(graph->os)[node]; i < j; i++) {
------------------
| | 60| 66.4k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1828:47): [True: 561k, False: 66.4k]
------------------
1829| 561k| igraph_int_t edge = VECTOR(graph->oi)[i];
------------------
| | 60| 561k|#define VECTOR(v) ((v).stor_begin)
------------------
1830| 561k| igraph_int_t other = VECTOR(graph->to)[edge];
------------------
| | 60| 561k|#define VECTOR(v) ((v).stor_begin)
------------------
1831| 561k| if (loops == IGRAPH_NO_LOOPS && other == pnode) {
------------------
| Branch (1831:21): [True: 0, False: 561k]
| Branch (1831:49): [True: 0, False: 0]
------------------
1832| 0| length--;
1833| 561k| } else {
1834| 561k| VECTOR(*eids)[idx++] = edge;
------------------
| | 60| 561k|#define VECTOR(v) ((v).stor_begin)
------------------
1835| 561k| }
1836| 561k| }
1837| 66.4k| }
1838| |
1839| 66.4k| if (mode & IGRAPH_IN) {
------------------
| Branch (1839:13): [True: 64.2k, False: 2.20k]
------------------
1840| 64.2k| j = VECTOR(graph->is)[node + 1];
------------------
| | 60| 64.2k|#define VECTOR(v) ((v).stor_begin)
------------------
1841| 438k| for (i = VECTOR(graph->is)[node]; i < j; i++) {
------------------
| | 60| 64.2k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1841:47): [True: 374k, False: 64.2k]
------------------
1842| 374k| igraph_int_t edge = VECTOR(graph->ii)[i];
------------------
| | 60| 374k|#define VECTOR(v) ((v).stor_begin)
------------------
1843| 374k| igraph_int_t other = VECTOR(graph->from)[edge];
------------------
| | 60| 374k|#define VECTOR(v) ((v).stor_begin)
------------------
1844| 374k| if ((loops == IGRAPH_NO_LOOPS || (loops == IGRAPH_LOOPS_ONCE && !directed)) && other == pnode) {
------------------
| Branch (1844:22): [True: 0, False: 374k]
| Branch (1844:51): [True: 0, False: 374k]
| Branch (1844:81): [True: 0, False: 0]
| Branch (1844:96): [True: 0, False: 0]
------------------
1845| 0| length--;
1846| 374k| } else {
1847| 374k| VECTOR(*eids)[idx++] = edge;
------------------
| | 60| 374k|#define VECTOR(v) ((v).stor_begin)
------------------
1848| 374k| }
1849| 374k| }
1850| 64.2k| }
1851| 66.4k| } else {
1852| | /* both in- and out- neighbors in a directed graph,
1853| | we need to merge the two 'vectors' */
1854| 0| igraph_int_t j1 = VECTOR(graph->os)[node + 1];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1855| 0| igraph_int_t j2 = VECTOR(graph->is)[node + 1];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1856| 0| igraph_int_t i1 = VECTOR(graph->os)[node];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1857| 0| igraph_int_t i2 = VECTOR(graph->is)[node];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1858| 0| igraph_int_t eid1, eid2;
1859| 0| igraph_int_t n1, n2;
1860| 0| igraph_bool_t seen_loop_edge = false;
1861| |
1862| 0| while (i1 < j1 && i2 < j2) {
------------------
| Branch (1862:16): [True: 0, False: 0]
| Branch (1862:27): [True: 0, False: 0]
------------------
1863| 0| eid1 = VECTOR(graph->oi)[i1];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1864| 0| eid2 = VECTOR(graph->ii)[i2];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1865| 0| n1 = VECTOR(graph->to)[eid1];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1866| 0| n2 = VECTOR(graph->from)[eid2];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1867| 0| if (n1 < n2) {
------------------
| Branch (1867:17): [True: 0, False: 0]
------------------
1868| 0| i1++;
1869| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1870| 0| } else if (n1 > n2) {
------------------
| Branch (1870:24): [True: 0, False: 0]
------------------
1871| 0| i2++;
1872| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1873| 0| } else if (n1 != pnode) {
------------------
| Branch (1873:24): [True: 0, False: 0]
------------------
1874| | /* multiple edge */
1875| 0| i1++;
1876| 0| i2++;
1877| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1878| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1879| 0| } else {
1880| | /* loop edge */
1881| 0| i1++;
1882| 0| i2++;
1883| 0| if (loops == IGRAPH_NO_LOOPS) {
------------------
| Branch (1883:21): [True: 0, False: 0]
------------------
1884| 0| length -= 2;
1885| 0| } else if (loops == IGRAPH_LOOPS_ONCE) {
------------------
| Branch (1885:28): [True: 0, False: 0]
------------------
1886| 0| length--;
1887| 0| if (!seen_loop_edge) {
------------------
| Branch (1887:25): [True: 0, False: 0]
------------------
1888| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1889| 0| } else {
1890| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1891| 0| }
1892| 0| seen_loop_edge = !seen_loop_edge;
1893| 0| } else {
1894| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1895| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1896| 0| }
1897| 0| }
1898| 0| }
1899| |
1900| 0| while (i1 < j1) {
------------------
| Branch (1900:16): [True: 0, False: 0]
------------------
1901| 0| eid1 = VECTOR(graph->oi)[i1++];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1902| 0| VECTOR(*eids)[idx++] = eid1;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1903| 0| }
1904| |
1905| 0| while (i2 < j2) {
------------------
| Branch (1905:16): [True: 0, False: 0]
------------------
1906| 0| eid2 = VECTOR(graph->ii)[i2++];
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1907| 0| VECTOR(*eids)[idx++] = eid2;
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
1908| 0| }
1909| 0| }
1910| 66.4k| IGRAPH_CHECK(igraph_vector_int_resize(eids, length));
------------------
| | 656| 66.4k| do { \
| | 657| 66.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 66.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 66.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 66.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| 66.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 66.4k]
| | ------------------
------------------
1911| 66.4k| return IGRAPH_SUCCESS;
1912| 66.4k|}
type_indexededgelist.c:igraph_i_create_start_vectors:
1076| 35.1k| igraph_vector_int_t *iindex, igraph_int_t nodes) {
1077| |
1078| 35.1k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
1079| |
1080| 35.1k| igraph_int_t no_of_nodes;
1081| 35.1k| igraph_int_t no_of_edges;
1082| 35.1k| igraph_int_t i, j, idx;
1083| |
1084| 35.1k| no_of_nodes = nodes;
1085| 35.1k| no_of_edges = igraph_vector_int_size(el);
1086| |
1087| | /* result */
1088| |
1089| 35.1k| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1));
------------------
| | 656| 35.1k| do { \
| | 657| 35.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 35.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 35.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 35.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| 35.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 35.1k]
| | ------------------
------------------
1090| |
1091| | /* create the index */
1092| |
1093| 35.1k| if (no_of_edges == 0) {
------------------
| Branch (1093:9): [True: 9.65k, False: 25.5k]
------------------
1094| | /* empty graph */
1095| 9.65k| igraph_vector_int_null(res);
1096| 25.5k| } else {
1097| 25.5k| idx = -1;
1098| 63.1k| for (i = 0; i <= EDGE(0); i++) {
------------------
| | 1078| 63.1k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 63.1k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 63.1k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (1098:21): [True: 37.6k, False: 25.5k]
------------------
1099| 37.6k| idx++; VECTOR(*res)[idx] = 0;
------------------
| | 60| 37.6k|#define VECTOR(v) ((v).stor_begin)
------------------
1100| 37.6k| }
1101| 2.79M| for (i = 1; i < no_of_edges; i++) {
------------------
| Branch (1101:21): [True: 2.77M, False: 25.5k]
------------------
1102| 2.77M| igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 2.77M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 2.77M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 2.77M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 2.77M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 2.77M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 2.77M|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1103| 3.01M| for (j = 0; j < n; j++) {
------------------
| Branch (1103:25): [True: 245k, False: 2.77M]
------------------
1104| 245k| idx++; VECTOR(*res)[idx] = i;
------------------
| | 60| 245k|#define VECTOR(v) ((v).stor_begin)
------------------
1105| 245k| }
1106| 2.77M| }
1107| 25.5k| j = EDGE(VECTOR(*res)[idx]);
------------------
| | 1078| 25.5k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 25.5k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ])
| | ------------------
| | | | 60| 25.5k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1108| 70.3k| for (i = 0; i < no_of_nodes - j; i++) {
------------------
| Branch (1108:21): [True: 44.8k, False: 25.5k]
------------------
1109| 44.8k| idx++; VECTOR(*res)[idx] = no_of_edges;
------------------
| | 60| 44.8k|#define VECTOR(v) ((v).stor_begin)
------------------
1110| 44.8k| }
1111| 25.5k| }
1112| |
1113| | /* clean */
1114| |
1115| 35.1k|# undef EDGE
1116| 35.1k| return IGRAPH_SUCCESS;
1117| 35.1k|}
igraph_qsort:
264| 33|{
265| | local_qsort(a, n, es, cmp, NULL);
266| 33|}
qsort.c:local_qsort:
121| 33|{
122| 33| char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
123| 33| size_t d1, d2;
124| 33| int cmp_result;
125| 33| int swap_cnt;
126| |
127| | /* if there are less than 2 elements, then sorting is not needed */
128| 33| if (IGRAPH_UNLIKELY(n < 2))
------------------
| | 612| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | ------------------
| | | Branch (612:32): [True: 0, False: 33]
| | ------------------
------------------
129| 0| return;
130| 33|loop:
131| 33| swap_cnt = 0;
132| 33| if (n < 7) {
------------------
| Branch (132:6): [True: 5, False: 28]
------------------
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| 28| pm = (char *)a + (n / 2) * es;
141| 28| if (n > 7) {
------------------
| Branch (141:6): [True: 27, False: 1]
------------------
142| 27| pl = a;
143| 27| pn = (char *)a + (n - 1) * es;
144| 27| if (n > 40) {
------------------
| Branch (144:7): [True: 14, False: 13]
------------------
145| 14| size_t d = (n / 8) * es;
146| |
147| 14| pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk);
148| 14| pm = med3(pm - d, pm, pm + d, cmp, thunk);
149| 14| pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk);
150| 14| }
151| 27| pm = med3(pl, pm, pn, cmp, thunk);
152| 27| }
153| 28| swapfunc(a, pm, es);
154| 28| pa = pb = (char *)a + es;
155| |
156| 28| pc = pd = (char *)a + (n - 1) * es;
157| 28| for (;;) {
158| 1.80k| while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) {
------------------
| | 95| 1.77k|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (158:10): [True: 1.77k, False: 28]
| Branch (158:22): [True: 1.77k, False: 0]
------------------
159| 1.77k| if (cmp_result == 0) {
------------------
| Branch (159:8): [True: 1.77k, False: 0]
------------------
160| 1.77k| swap_cnt = 1;
161| 1.77k| swapfunc(pa, pb, es);
162| 1.77k| pa += es;
163| 1.77k| }
164| 1.77k| pb += es;
165| 1.77k| }
166| 28| 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: 28]
| 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| 28| if (pb > pc)
------------------
| Branch (174:7): [True: 28, False: 0]
------------------
175| 28| break;
176| 0| swapfunc(pb, pc, es);
177| 0| swap_cnt = 1;
178| 0| pb += es;
179| 0| pc -= es;
180| 0| }
181| 28| if (swap_cnt == 0) { /* Switch to insertion sort */
------------------
| Branch (181:6): [True: 0, False: 28]
------------------
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| 28| pn = (char *)a + n * es;
191| 28| d1 = MIN(pa - (char *)a, pb - pa);
------------------
| | 69| 28|#define MIN(a, b) ((a) < (b) ? a : b)
| | ------------------
| | | Branch (69:20): [True: 0, False: 28]
| | ------------------
------------------
192| 28| vecswap(a, pb - d1, d1);
------------------
| | 88| 28| if ((n) > 0) swapfunc(a, b, n)
| | ------------------
| | | Branch (88:6): [True: 0, False: 28]
| | ------------------
------------------
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| 28| d1 = MIN(pd - pc, pn - pd - (ptrdiff_t)es);
------------------
| | 69| 28|#define MIN(a, b) ((a) < (b) ? a : b)
| | ------------------
| | | Branch (69:20): [True: 0, False: 28]
| | ------------------
------------------
199| 28| vecswap(pb, pn - d1, d1);
------------------
| | 88| 28| if ((n) > 0) swapfunc(a, b, n)
| | ------------------
| | | Branch (88:6): [True: 0, False: 28]
| | ------------------
------------------
200| |
201| 28| d1 = pb - pa;
202| 28| d2 = pd - pc;
203| 28| if (d1 <= d2) {
------------------
| Branch (203:6): [True: 28, False: 0]
------------------
204| | /* Recurse on left partition, then iterate on right partition */
205| 28| if (d1 > es) {
------------------
| Branch (205:7): [True: 0, False: 28]
------------------
206| 0| local_qsort(a, d1 / es, es, cmp, thunk);
207| 0| }
208| 28| if (d2 > es) {
------------------
| Branch (208:7): [True: 0, False: 28]
------------------
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| 28| } 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| 28|}
qsort.c:swapfunc:
77| 1.80k|{
78| 1.80k| char t;
79| |
80| 14.4k| do {
81| 14.4k| t = *a;
82| 14.4k| *a++ = *b;
83| 14.4k| *b++ = t;
84| 14.4k| } while (--es > 0);
------------------
| Branch (84:11): [True: 12.6k, False: 1.80k]
------------------
85| 1.80k|}
qsort.c:med3:
104| 69|{
105| 69| return CMP(thunk, a, b) < 0 ?
------------------
| | 95| 69|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (105:9): [True: 0, False: 69]
------------------
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| 69| :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));
------------------
| | 95| 69|#define CMP(t, x, y) (cmp((x), (y)))
------------------
:(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));
------------------
| | 95| 69|#define CMP(t, x, y) (cmp((x), (y)))
------------------
| Branch (107:10): [True: 0, False: 69]
| Branch (107:38): [True: 0, False: 69]
------------------
108| 69|}
igraph_write_graph_dot:
160| 3.57k|igraph_error_t igraph_write_graph_dot(const igraph_t *graph, FILE* outstream) {
161| 3.57k| const igraph_int_t no_of_nodes = igraph_vcount(graph);
162| 3.57k| const igraph_int_t no_of_edges = igraph_ecount(graph);
163| 3.57k| const igraph_bool_t directed = igraph_is_directed(graph);
164| 3.57k| const char *edgeop = directed ? "->" : "--";
------------------
| Branch (164:26): [True: 134, False: 3.44k]
------------------
165| 3.57k| igraph_strvector_t gnames, vnames, enames;
166| 3.57k| igraph_vector_int_t gtypes, vtypes, etypes;
167| 3.57k| igraph_vector_t numv;
168| 3.57k| igraph_strvector_t strv;
169| 3.57k| igraph_vector_bool_t boolv;
170| 3.57k| igraph_vector_char_t buf, buf2;
171| |
172| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
173| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
174| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
175| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
176| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
177| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
178| 3.57k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
179| 3.57k| &gnames, >ypes,
180| 3.57k| &vnames, &vtypes,
181| 3.57k| &enames, &etypes));
182| |
183| 3.57k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 0);
------------------
| | 104| 3.57k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 105| 3.57k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.57k]
| | ------------------
------------------
184| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
185| 3.57k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 0);
------------------
| | 109| 3.57k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 110| 3.57k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.57k]
| | ------------------
------------------
186| |
187| 3.57k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&buf, 0);
------------------
| | 114| 3.57k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 115| 3.57k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 3.57k]
| | ------------------
------------------
188| 3.57k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&buf2, 0);
------------------
| | 114| 3.57k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 115| 3.57k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 3.57k]
| | ------------------
------------------
189| |
190| 3.57k| CHECK(fprintf(outstream, "/* Created by igraph %s */\n", IGRAPH_VERSION));
------------------
| | 37| 3.57k|#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.57k]
| | | Branch (37:116): [Folded, False: 3.57k]
| | ------------------
------------------
191| |
192| 3.57k| if (directed) {
------------------
| Branch (192:9): [True: 134, False: 3.44k]
------------------
193| 134| CHECK(fprintf(outstream, "digraph {\n"));
------------------
| | 37| 134|#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: 134]
| | | Branch (37:116): [Folded, False: 134]
| | ------------------
------------------
194| 3.44k| } else {
195| 3.44k| CHECK(fprintf(outstream, "graph {\n"));
------------------
| | 37| 3.44k|#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.44k]
| | | Branch (37:116): [Folded, False: 3.44k]
| | ------------------
------------------
196| 3.44k| }
197| |
198| | /* Write the graph attributes */
199| 3.57k| if (igraph_vector_int_size(>ypes) > 0) {
------------------
| Branch (199:9): [True: 540, False: 3.03k]
------------------
200| 540| CHECK(fprintf(outstream, " graph [\n"));
------------------
| | 37| 540|#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: 540]
| | | Branch (37:116): [Folded, False: 540]
| | ------------------
------------------
201| 1.40k| for (igraph_int_t i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (201:34): [True: 865, False: 540]
------------------
202| 865| const char *name;
203| 865| name = igraph_strvector_get(&gnames, i);
204| 865| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 656| 865| do { \
| | 657| 865| igraph_error_t igraph_i_ret = (expr); \
| | 658| 865| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 865| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 865]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 865| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 865]
| | ------------------
------------------
205| 865| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 865|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (205:17): [True: 87, False: 778]
------------------
206| 87| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 87| do { \
| | 657| 87| igraph_error_t igraph_i_ret = (expr); \
| | 658| 87| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 87| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 87]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 87| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 87]
| | ------------------
------------------
207| 87| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 87|#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: 87]
| | | Branch (37:116): [Folded, False: 87]
| | ------------------
------------------
208| 87| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 87| do { \
| | 657| 87| igraph_error_t igraph_i_ret = (expr); \
| | 658| 87| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 87| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 87]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 87| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 87]
| | ------------------
------------------
209| 87| CHECK(fputc('\n', outstream));
------------------
| | 37| 87|#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: 87]
| | | Branch (37:116): [Folded, False: 87]
| | ------------------
------------------
210| 778| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 778|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (210:24): [True: 628, False: 150]
------------------
211| 628| const char *s;
212| 628| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 628| do { \
| | 657| 628| igraph_error_t igraph_i_ret = (expr); \
| | 658| 628| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 628| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 628]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 628| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 628]
| | ------------------
------------------
213| 628| s = igraph_strvector_get(&strv, 0);
214| 628| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 628| do { \
| | 657| 628| igraph_error_t igraph_i_ret = (expr); \
| | 658| 628| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 628| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 628]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 628| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 628]
| | ------------------
------------------
215| 628| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 628|#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: 628]
| | | Branch (37:116): [Folded, False: 628]
| | ------------------
------------------
216| 628| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 150|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (216:24): [True: 150, False: 0]
------------------
217| 150| IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
------------------
| | 656| 150| do { \
| | 657| 150| igraph_error_t igraph_i_ret = (expr); \
| | 658| 150| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 150| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 150]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 150| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 150]
| | ------------------
------------------
218| 150| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 300|#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: 149]
| | | Branch (37:42): [True: 0, False: 150]
| | | Branch (37:116): [Folded, False: 150]
| | ------------------
------------------
219| 150| IGRAPH_WARNING("Boolean graph attribute was converted to numeric.");
------------------
| | 797| 150| do { \
| | 798| 150| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 150| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 150]
| | ------------------
------------------
220| 150| } 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| 865| }
224| 540| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 540|#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: 540]
| | | Branch (37:116): [Folded, False: 540]
| | ------------------
------------------
225| 540| }
226| |
227| | /* Write the vertices */
228| 3.57k| if (igraph_vector_int_size(&vtypes) > 0) {
------------------
| Branch (228:9): [True: 3.56k, False: 13]
------------------
229| 36.5k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (229:34): [True: 32.9k, False: 3.56k]
------------------
230| 32.9k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " [\n", i));
------------------
| | 37| 32.9k|#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.9k]
| | | Branch (37:116): [Folded, False: 32.9k]
| | ------------------
------------------
231| 84.9k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vtypes); j++) {
------------------
| Branch (231:38): [True: 51.9k, False: 32.9k]
------------------
232| 51.9k| const char *name;
233| 51.9k| name = igraph_strvector_get(&vnames, j);
234| 51.9k| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 656| 51.9k| do { \
| | 657| 51.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.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| 51.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.9k]
| | ------------------
------------------
235| 51.9k| if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 51.9k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (235:21): [True: 4.99k, False: 46.9k]
------------------
236| 4.99k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name, igraph_vss_1(i), &numv));
------------------
| | 656| 4.99k| do { \
| | 657| 4.99k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.99k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.99k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.99k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.99k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.99k]
| | ------------------
------------------
237| 4.99k| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 4.99k|#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.99k]
| | | Branch (37:116): [Folded, False: 4.99k]
| | ------------------
------------------
238| 4.99k| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 4.99k| do { \
| | 657| 4.99k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.99k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.99k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.99k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.99k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.99k]
| | ------------------
------------------
239| 4.99k| CHECK(fputc('\n', outstream));
------------------
| | 37| 4.99k|#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.99k]
| | | Branch (37:116): [Folded, False: 4.99k]
| | ------------------
------------------
240| 46.9k| } else if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 46.9k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (240:28): [True: 42.3k, False: 4.62k]
------------------
241| 42.3k| const char *s;
242| 42.3k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name, igraph_vss_1(i), &strv));
------------------
| | 656| 42.3k| do { \
| | 657| 42.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.3k]
| | ------------------
------------------
243| 42.3k| s = igraph_strvector_get(&strv, 0);
244| 42.3k| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 42.3k| do { \
| | 657| 42.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.3k]
| | ------------------
------------------
245| 42.3k| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 42.3k|#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.3k]
| | | Branch (37:116): [Folded, False: 42.3k]
| | ------------------
------------------
246| 42.3k| } else if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 4.62k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (246:28): [True: 4.62k, False: 0]
------------------
247| 4.62k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name, igraph_vss_1(i), &boolv));
------------------
| | 656| 4.62k| do { \
| | 657| 4.62k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.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| 4.62k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.62k]
| | ------------------
------------------
248| 4.62k| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 9.25k|#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: 20, False: 4.60k]
| | | Branch (37:42): [True: 0, False: 4.62k]
| | | Branch (37:116): [Folded, False: 4.62k]
| | ------------------
------------------
249| 4.62k| IGRAPH_WARNING("A boolean vertex attribute was converted to numeric.");
------------------
| | 797| 4.62k| do { \
| | 798| 4.62k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 4.62k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 4.62k]
| | ------------------
------------------
250| 4.62k| } 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.9k| }
254| 32.9k| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 32.9k|#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.9k]
| | | Branch (37:116): [Folded, False: 32.9k]
| | ------------------
------------------
255| 32.9k| }
256| 3.56k| } else {
257| 243| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (257:34): [True: 230, False: 13]
------------------
258| 230| CHECK(fprintf(outstream, " %" IGRAPH_PRId ";\n", i));
------------------
| | 37| 230|#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: 230]
| | | Branch (37:116): [Folded, False: 230]
| | ------------------
------------------
259| 230| }
260| 13| }
261| 3.57k| CHECK(fprintf(outstream, "\n"));
------------------
| | 37| 3.57k|#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.57k]
| | | Branch (37:116): [Folded, False: 3.57k]
| | ------------------
------------------
262| |
263| | /* Write the edges */
264| 3.57k| if (igraph_vector_int_size(&etypes) > 0) {
------------------
| Branch (264:9): [True: 1.69k, False: 1.88k]
------------------
265| 173k| for (igraph_int_t i = 0; i < no_of_edges; i++) {
------------------
| Branch (265:34): [True: 171k, False: 1.69k]
------------------
266| 171k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 171k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 171k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
267| 171k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 171k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 171k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
268| 171k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " %s %" IGRAPH_PRId " [\n", from, edgeop, to));
------------------
| | 37| 171k|#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: 171k]
| | | Branch (37:116): [Folded, False: 171k]
| | ------------------
------------------
269| 571k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&etypes); j++) {
------------------
| Branch (269:38): [True: 400k, False: 171k]
------------------
270| 400k| const char *name;
271| 400k| name = igraph_strvector_get(&enames, j);
272| 400k| IGRAPH_CHECK(dot_escape(name, &buf));
------------------
| | 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]
| | ------------------
------------------
273| 400k| if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 400k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (273:21): [True: 85.7k, False: 314k]
------------------
274| 85.7k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph,
------------------
| | 656| 85.7k| do { \
| | 657| 85.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 85.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 85.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.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| 85.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 85.7k]
| | ------------------
------------------
275| 85.7k| name, igraph_ess_1(i), &numv));
276| 85.7k| CHECK(fprintf(outstream, " %s=", VECTOR(buf)));
------------------
| | 37| 85.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:42): [True: 0, False: 85.7k]
| | | Branch (37:116): [Folded, False: 85.7k]
| | ------------------
------------------
277| 85.7k| IGRAPH_CHECK(fprint_integral_or_precise(outstream, VECTOR(numv)[0], &buf));
------------------
| | 656| 85.7k| do { \
| | 657| 85.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 85.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 85.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.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| 85.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 85.7k]
| | ------------------
------------------
278| 85.7k| CHECK(fputc('\n', outstream));
------------------
| | 37| 85.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:42): [True: 0, False: 85.7k]
| | | Branch (37:116): [Folded, False: 85.7k]
| | ------------------
------------------
279| 314k| } else if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 314k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (279:28): [True: 308k, False: 5.79k]
------------------
280| 308k| const char *s;
281| 308k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph,
------------------
| | 656| 308k| do { \
| | 657| 308k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 308k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 308k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 308k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 308k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 308k]
| | ------------------
------------------
282| 308k| name, igraph_ess_1(i), &strv));
283| 308k| s = igraph_strvector_get(&strv, 0);
284| 308k| IGRAPH_CHECK(dot_escape(s, &buf2));
------------------
| | 656| 308k| do { \
| | 657| 308k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 308k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 308k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 308k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 308k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 308k]
| | ------------------
------------------
285| 308k| CHECK(fprintf(outstream, " %s=%s\n", VECTOR(buf), VECTOR(buf2)));
------------------
| | 37| 308k|#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: 308k]
| | | Branch (37:116): [Folded, False: 308k]
| | ------------------
------------------
286| 308k| } else if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 5.79k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (286:28): [True: 5.79k, False: 0]
------------------
287| 5.79k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph,
------------------
| | 656| 5.79k| do { \
| | 657| 5.79k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.79k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.79k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.79k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.79k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.79k]
| | ------------------
------------------
288| 5.79k| name, igraph_ess_1(i), &boolv));
289| 5.79k| CHECK(fprintf(outstream, " %s=%d\n", VECTOR(buf), VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 37| 11.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:33): [True: 0, False: 5.79k]
| | | Branch (37:42): [True: 0, False: 5.79k]
| | | Branch (37:116): [Folded, False: 5.79k]
| | ------------------
------------------
290| 5.79k| IGRAPH_WARNING("A boolean edge attribute was converted to numeric.");
------------------
| | 797| 5.79k| do { \
| | 798| 5.79k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 5.79k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 5.79k]
| | ------------------
------------------
291| 5.79k| } 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| 400k| }
295| 171k| CHECK(fprintf(outstream, " ];\n"));
------------------
| | 37| 171k|#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: 171k]
| | | Branch (37:116): [Folded, False: 171k]
| | ------------------
------------------
296| 171k| }
297| 1.88k| } else {
298| 110k| for (igraph_int_t i = 0; i < no_of_edges; i++) {
------------------
| Branch (298:34): [True: 108k, False: 1.88k]
------------------
299| 108k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 108k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 108k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
300| 108k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 108k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 108k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
301| 108k| CHECK(fprintf(outstream, " %" IGRAPH_PRId " %s %" IGRAPH_PRId ";\n", from, edgeop, to));
------------------
| | 37| 108k|#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: 108k]
| | | Branch (37:116): [Folded, False: 108k]
| | ------------------
------------------
302| 108k| }
303| 1.88k| }
304| 3.57k| CHECK(fprintf(outstream, "}\n"));
------------------
| | 37| 3.57k|#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.57k]
| | | Branch (37:116): [Folded, False: 3.57k]
| | ------------------
------------------
305| |
306| 3.57k| igraph_vector_char_destroy(&buf2);
307| 3.57k| igraph_vector_char_destroy(&buf);
308| 3.57k| igraph_vector_bool_destroy(&boolv);
309| 3.57k| igraph_strvector_destroy(&strv);
310| 3.57k| igraph_vector_destroy(&numv);
311| 3.57k| igraph_vector_int_destroy(&etypes);
312| 3.57k| igraph_vector_int_destroy(&vtypes);
313| 3.57k| igraph_vector_int_destroy(>ypes);
314| 3.57k| igraph_strvector_destroy(&enames);
315| 3.57k| igraph_strvector_destroy(&vnames);
316| 3.57k| igraph_strvector_destroy(&gnames);
317| 3.57k| IGRAPH_FINALLY_CLEAN(11);
318| |
319| 3.57k| return IGRAPH_SUCCESS;
320| 3.57k|}
dot.c:dot_escape:
39| 891k|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| 891k| igraph_int_t i, j, len = strlen(orig), newlen = 0;
42| 891k| 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| 891k| if (!strcasecmp(orig, "graph") || !strcasecmp(orig, "digraph") ||
------------------
| Branch (45:9): [True: 194, False: 891k]
| Branch (45:39): [True: 66, False: 890k]
------------------
46| 890k| !strcasecmp(orig, "node") || !strcasecmp(orig, "edge") ||
------------------
| Branch (46:9): [True: 195, False: 890k]
| Branch (46:38): [True: 198, False: 890k]
------------------
47| 890k| !strcasecmp(orig, "strict") || !strcasecmp(orig, "subgraph") || len == 0) {
------------------
| Branch (47:9): [True: 195, False: 890k]
| Branch (47:40): [True: 2.13k, False: 888k]
| Branch (47:73): [True: 113k, False: 774k]
------------------
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| 260M| for (i = 0; i < len; i++) {
------------------
| Branch (54:17): [True: 259M, False: 891k]
------------------
55| 259M| if (isdigit(orig[i])) {
------------------
| Branch (55:13): [True: 7.69M, False: 252M]
------------------
56| 7.69M| newlen++;
57| 252M| } else if (orig[i] == '-' && i == 0) {
------------------
| Branch (57:20): [True: 2.37M, False: 249M]
| Branch (57:38): [True: 3.82k, False: 2.37M]
------------------
58| 3.82k| newlen++;
59| 252M| } else if (orig[i] == '.') {
------------------
| Branch (59:20): [True: 1.12M, False: 251M]
------------------
60| 1.12M| if (is_number) {
------------------
| Branch (60:17): [True: 3.74k, False: 1.12M]
------------------
61| 3.74k| newlen++;
62| 1.12M| } else {
63| 1.12M| need_quote = true;
64| 1.12M| newlen++;
65| 1.12M| }
66| 251M| } else if (orig[i] == '_') {
------------------
| Branch (66:20): [True: 3.12M, False: 248M]
------------------
67| 3.12M| is_number = false; newlen++;
68| 248M| } else if (orig[i] == '\\' || orig[i] == '"' || orig[i] == '\n') {
------------------
| Branch (68:20): [True: 12.9k, False: 248M]
| Branch (68:39): [True: 15.5M, False: 232M]
| Branch (68:57): [True: 11.2M, False: 221M]
------------------
69| 26.7M| need_quote = true; is_number = false; newlen += 2; /* will be escaped */
70| 221M| } else if (isalpha(orig[i])) {
------------------
| Branch (70:20): [True: 39.8M, False: 181M]
------------------
71| 39.8M| is_number = false; newlen++;
72| 181M| } else {
73| 181M| is_number = false; need_quote = true; newlen++;
74| 181M| }
75| 259M| }
76| 891k| if (is_number && len > 0 && orig[len - 1] == '.') {
------------------
| Branch (76:9): [True: 5.40k, False: 885k]
| Branch (76:22): [True: 5.40k, False: 0]
| Branch (76:33): [True: 485, False: 4.92k]
------------------
77| 485| is_number = false;
78| 485| }
79| 891k| if (!is_number && isdigit(orig[0])) {
------------------
| Branch (79:9): [True: 886k, False: 4.92k]
| Branch (79:23): [True: 3.53k, False: 882k]
------------------
80| 3.53k| need_quote = true;
81| 3.53k| }
82| |
83| 891k| if (is_number || !need_quote) {
------------------
| Branch (83:9): [True: 4.92k, False: 886k]
| Branch (83:22): [True: 723k, False: 162k]
------------------
84| 728k| IGRAPH_CHECK(igraph_vector_char_resize(result, newlen + 1));
------------------
| | 656| 728k| do { \
| | 657| 728k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 728k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 728k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 728k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 728k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 728k]
| | ------------------
------------------
85| 728k| memcpy(VECTOR(*result), orig, newlen);
------------------
| | 60| 728k|#define VECTOR(v) ((v).stor_begin)
------------------
86| 728k| } else {
87| 162k| newlen += 2;
88| 162k| IGRAPH_CHECK(igraph_vector_char_resize(result, newlen + 1));
------------------
| | 656| 162k| do { \
| | 657| 162k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 162k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 162k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 162k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 162k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 162k]
| | ------------------
------------------
89| 162k| VECTOR(*result)[0] = '"';
------------------
| | 60| 162k|#define VECTOR(v) ((v).stor_begin)
------------------
90| 162k| VECTOR(*result)[newlen - 1] = '"';
------------------
| | 60| 162k|#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| 247M| for (i = 0, j = 1; i < len; i++) {
------------------
| Branch (97:28): [True: 247M, False: 162k]
------------------
98| 247M| if (orig[i] == '\n') {
------------------
| Branch (98:17): [True: 11.2M, False: 236M]
------------------
99| 11.2M| VECTOR(*result)[j++] = '\\';
------------------
| | 60| 11.2M|#define VECTOR(v) ((v).stor_begin)
------------------
100| 11.2M| VECTOR(*result)[j++] = 'n';
------------------
| | 60| 11.2M|#define VECTOR(v) ((v).stor_begin)
------------------
101| 11.2M| continue;
102| 11.2M| }
103| 236M| if (orig[i] == '\\' || orig[i] == '"') {
------------------
| Branch (103:17): [True: 12.9k, False: 236M]
| Branch (103:36): [True: 15.5M, False: 220M]
------------------
104| 15.5M| VECTOR(*result)[j++] = '\\';
------------------
| | 60| 15.5M|#define VECTOR(v) ((v).stor_begin)
------------------
105| 15.5M| }
106| 236M| VECTOR(*result)[j++] = orig[i];
------------------
| | 60| 236M|#define VECTOR(v) ((v).stor_begin)
------------------
107| 236M| }
108| 162k| }
109| 891k| VECTOR(*result)[newlen] = 0;
------------------
| | 60| 891k|#define VECTOR(v) ((v).stor_begin)
------------------
110| |
111| 891k| return IGRAPH_SUCCESS;
112| 891k|}
dot.c:fprint_integral_or_precise:
117| 90.8k|static igraph_error_t fprint_integral_or_precise(FILE *file, igraph_real_t x, igraph_vector_char_t *buf) {
118| 90.8k| if (fabs(x) <= IGRAPH_MAX_EXACT_REAL && floor(x) == x) {
------------------
| | 35| 181k|#define IGRAPH_MAX_EXACT_REAL ((double)(1LL << DBL_MANT_DIG))
------------------
| Branch (118:9): [True: 5.10k, False: 85.7k]
| Branch (118:45): [True: 4.39k, False: 701]
------------------
119| | /* write exactly representable integral values in standard integer notation;
120| | * the above conditional skips +-Inf and NaN */
121| 4.39k| CHECK(fprintf(file, "%.f", x));
------------------
| | 37| 4.39k|#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.39k]
| | | Branch (37:116): [Folded, False: 4.39k]
| | ------------------
------------------
122| 86.4k| } else {
123| | /* write as precise float and quote if necessary */
124| 86.4k| char str[50]; /* large enough to hold any precisely printed real */
125| 86.4k| CHECK(igraph_real_snprintf_precise(str, sizeof(str) / sizeof(str[0]), x));
------------------
| | 37| 86.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: 86.4k]
| | | Branch (37:116): [Folded, False: 86.4k]
| | ------------------
------------------
126| 86.4k| IGRAPH_CHECK(dot_escape(str, buf));
------------------
| | 656| 86.4k| do { \
| | 657| 86.4k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 86.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 86.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 86.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| 86.4k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 86.4k]
| | ------------------
------------------
127| 86.4k| CHECK(fputs(VECTOR(*buf), file));
------------------
| | 37| 86.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: 86.4k]
| | | Branch (37:116): [Folded, False: 86.4k]
| | ------------------
------------------
128| 86.4k| }
129| 90.8k| return IGRAPH_SUCCESS;
130| 90.8k|}
igraph_gml_tree_init_integer:
31| 614k| igraph_int_t value) {
32| |
33| 614k| igraph_int_t *p;
34| |
35| 614k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 614k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 614k| do { \
| | | | 657| 614k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 614k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 614k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 614k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 614k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 614k]
| | | | ------------------
| | ------------------
| | 47| 614k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 614k| do { \
| | | | 604| 614k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 614k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 614k| * incorrect destructor function with the pointer */ \
| | | | 607| 614k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 614k]
| | | | ------------------
| | | | 608| 614k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 614k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 614k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 614k]
| | ------------------
------------------
36| 614k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 614k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 614k| do { \
| | | | 657| 614k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 614k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 614k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 614k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 614k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 614k]
| | | | ------------------
| | ------------------
| | 115| 614k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 614k| do { \
| | | | 604| 614k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 614k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 614k| * incorrect destructor function with the pointer */ \
| | | | 607| 614k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 614k]
| | | | ------------------
| | | | 608| 614k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 614k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 614k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 614k]
| | ------------------
------------------
37| 614k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 614k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 614k| do { \
| | | | 657| 614k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 614k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 614k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 614k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 614k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 614k]
| | | | ------------------
| | ------------------
| | 47| 614k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 614k| do { \
| | | | 604| 614k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 614k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 614k| * incorrect destructor function with the pointer */ \
| | | | 607| 614k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 614k]
| | | | ------------------
| | | | 608| 614k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 614k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 614k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 614k]
| | ------------------
------------------
38| 614k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 614k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 614k| do { \
| | | | 657| 614k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 614k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 614k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 614k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 614k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 614k]
| | | | ------------------
| | ------------------
| | 120| 614k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 614k| do { \
| | | | 604| 614k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 614k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 614k| * incorrect destructor function with the pointer */ \
| | | | 607| 614k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 614k]
| | | | ------------------
| | | | 608| 614k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 614k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 614k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 614k]
| | ------------------
------------------
39| |
40| | /* names */
41| 614k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 614k|#define VECTOR(v) ((v).stor_begin)
------------------
42| |
43| | /* line number */
44| 614k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 614k|#define VECTOR(v) ((v).stor_begin)
------------------
45| |
46| | /* types */
47| 614k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_INTEGER;
------------------
| | 60| 614k|#define VECTOR(v) ((v).stor_begin)
------------------
48| |
49| | /* children */
50| 614k| p = IGRAPH_CALLOC(1, igraph_int_t);
------------------
| | 33| 614k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.22M| (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: 614k, Folded]
| | | | ------------------
| | ------------------
------------------
51| 614k| IGRAPH_CHECK_OOM(p, "Cannot create integer GML tree node.");
------------------
| | 709| 614k| do { \
| | 710| 614k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 614k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 614k]
| | | | ------------------
| | ------------------
| | 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| 614k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 614k]
| | ------------------
------------------
52| 614k| *p = value;
53| 614k| VECTOR(t->children)[0] = p;
------------------
| | 60| 614k|#define VECTOR(v) ((v).stor_begin)
------------------
54| |
55| 614k| IGRAPH_FINALLY_CLEAN(4);
56| 614k| return IGRAPH_SUCCESS;
57| 614k|}
igraph_gml_tree_init_real:
62| 954| igraph_real_t value) {
63| |
64| 954| igraph_real_t *p;
65| |
66| 954| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 954| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 954| do { \
| | | | 657| 954| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 954| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 954| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 954]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 954| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 954]
| | | | ------------------
| | ------------------
| | 47| 954| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 954| do { \
| | | | 604| 954| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 954| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 954| * incorrect destructor function with the pointer */ \
| | | | 607| 954| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 954]
| | | | ------------------
| | | | 608| 954| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 954| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 954]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 954]
| | ------------------
------------------
67| 954| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 954| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 954| do { \
| | | | 657| 954| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 954| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 954| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 954]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 954| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 954]
| | | | ------------------
| | ------------------
| | 115| 954| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 954| do { \
| | | | 604| 954| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 954| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 954| * incorrect destructor function with the pointer */ \
| | | | 607| 954| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 954]
| | | | ------------------
| | | | 608| 954| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 954| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 954]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 954]
| | ------------------
------------------
68| 954| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 954| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 954| do { \
| | | | 657| 954| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 954| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 954| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 954]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 954| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 954]
| | | | ------------------
| | ------------------
| | 47| 954| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 954| do { \
| | | | 604| 954| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 954| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 954| * incorrect destructor function with the pointer */ \
| | | | 607| 954| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 954]
| | | | ------------------
| | | | 608| 954| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 954| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 954]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 954]
| | ------------------
------------------
69| 954| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 954| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 954| do { \
| | | | 657| 954| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 954| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 954| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 954]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 954| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 954]
| | | | ------------------
| | ------------------
| | 120| 954| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 954| do { \
| | | | 604| 954| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 954| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 954| * incorrect destructor function with the pointer */ \
| | | | 607| 954| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 954]
| | | | ------------------
| | | | 608| 954| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 954| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 954]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 954]
| | ------------------
------------------
70| |
71| | /* names */
72| 954| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 954|#define VECTOR(v) ((v).stor_begin)
------------------
73| |
74| | /* line number */
75| 954| VECTOR(t->lines)[0] = line;
------------------
| | 60| 954|#define VECTOR(v) ((v).stor_begin)
------------------
76| |
77| | /* types */
78| 954| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_REAL;
------------------
| | 60| 954|#define VECTOR(v) ((v).stor_begin)
------------------
79| |
80| | /* children */
81| 954| p = IGRAPH_CALLOC(1, igraph_real_t);
------------------
| | 33| 954|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.90k| (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: 954, Folded]
| | | | ------------------
| | ------------------
------------------
82| 954| IGRAPH_CHECK_OOM(p, "Cannot create real GML tree node.");
------------------
| | 709| 954| do { \
| | 710| 954| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 954| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 954]
| | | | ------------------
| | ------------------
| | 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| 954| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 954]
| | ------------------
------------------
83| 954| *p = value;
84| 954| VECTOR(t->children)[0] = p;
------------------
| | 60| 954|#define VECTOR(v) ((v).stor_begin)
------------------
85| |
86| 954| IGRAPH_FINALLY_CLEAN(4);
87| 954| return IGRAPH_SUCCESS;
88| 954|}
igraph_gml_tree_init_string:
93| 323k| const char *value) {
94| |
95| 323k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 323k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 323k| do { \
| | | | 657| 323k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 323k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 323k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 323k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 323k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 323k]
| | | | ------------------
| | ------------------
| | 47| 323k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 323k| do { \
| | | | 604| 323k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 323k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 323k| * incorrect destructor function with the pointer */ \
| | | | 607| 323k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 323k]
| | | | ------------------
| | | | 608| 323k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 323k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 323k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 323k]
| | ------------------
------------------
96| 323k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 323k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 323k| do { \
| | | | 657| 323k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 323k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 323k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 323k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 323k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 323k]
| | | | ------------------
| | ------------------
| | 115| 323k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 323k| do { \
| | | | 604| 323k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 323k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 323k| * incorrect destructor function with the pointer */ \
| | | | 607| 323k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 323k]
| | | | ------------------
| | | | 608| 323k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 323k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 323k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 323k]
| | ------------------
------------------
97| 323k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 323k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 323k| do { \
| | | | 657| 323k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 323k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 323k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 323k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 323k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 323k]
| | | | ------------------
| | ------------------
| | 47| 323k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 323k| do { \
| | | | 604| 323k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 323k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 323k| * incorrect destructor function with the pointer */ \
| | | | 607| 323k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 323k]
| | | | ------------------
| | | | 608| 323k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 323k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 323k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 323k]
| | ------------------
------------------
98| 323k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 323k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 323k| do { \
| | | | 657| 323k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 323k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 323k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 323k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 323k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 323k]
| | | | ------------------
| | ------------------
| | 120| 323k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 323k| do { \
| | | | 604| 323k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 323k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 323k| * incorrect destructor function with the pointer */ \
| | | | 607| 323k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 323k]
| | | | ------------------
| | | | 608| 323k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 323k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 323k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 323k]
| | ------------------
------------------
99| |
100| | /* names */
101| 323k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 323k|#define VECTOR(v) ((v).stor_begin)
------------------
102| |
103| | /* line number */
104| 323k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 323k|#define VECTOR(v) ((v).stor_begin)
------------------
105| |
106| | /* types */
107| 323k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_STRING;
------------------
| | 60| 323k|#define VECTOR(v) ((v).stor_begin)
------------------
108| |
109| | /* children */
110| 323k| VECTOR(t->children)[0] = (void*) value;
------------------
| | 60| 323k|#define VECTOR(v) ((v).stor_begin)
------------------
111| |
112| 323k| IGRAPH_FINALLY_CLEAN(4);
113| 323k| return IGRAPH_SUCCESS;
114| 323k|}
igraph_gml_tree_init_tree:
119| 317k| igraph_gml_tree_t *value) {
120| |
121| 317k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
------------------
| | 46| 317k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 317k| do { \
| | | | 657| 317k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 317k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 317k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 317k]
| | | | ------------------
| | ------------------
| | 47| 317k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 317k| do { \
| | | | 604| 317k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 317k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 317k| * incorrect destructor function with the pointer */ \
| | | | 607| 317k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 317k]
| | | | ------------------
| | | | 608| 317k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 317k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 317k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 317k]
| | ------------------
------------------
122| 317k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&t->types, 1);
------------------
| | 114| 317k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 317k| do { \
| | | | 657| 317k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 317k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 317k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 317k]
| | | | ------------------
| | ------------------
| | 115| 317k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 317k| do { \
| | | | 604| 317k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 317k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 317k| * incorrect destructor function with the pointer */ \
| | | | 607| 317k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 317k]
| | | | ------------------
| | | | 608| 317k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 317k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 317k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 317k]
| | ------------------
------------------
123| 317k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);
------------------
| | 46| 317k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
| | ------------------
| | | | 656| 317k| do { \
| | | | 657| 317k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 317k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 317k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 317k]
| | | | ------------------
| | ------------------
| | 47| 317k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)
| | ------------------
| | | | 603| 317k| do { \
| | | | 604| 317k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 317k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 317k| * incorrect destructor function with the pointer */ \
| | | | 607| 317k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 317k]
| | | | ------------------
| | | | 608| 317k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 317k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 317k]
| | | | ------------------
| | ------------------
| | | Branch (47:65): [Folded, False: 317k]
| | ------------------
------------------
124| 317k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->lines, 1);
------------------
| | 119| 317k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 317k| do { \
| | | | 657| 317k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 317k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 317k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 317k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 317k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 317k]
| | | | ------------------
| | ------------------
| | 120| 317k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 317k| do { \
| | | | 604| 317k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 317k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 317k| * incorrect destructor function with the pointer */ \
| | | | 607| 317k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 317k]
| | | | ------------------
| | | | 608| 317k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 317k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 317k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 317k]
| | ------------------
------------------
125| |
126| | /* names */
127| 317k| VECTOR(t->names)[0] = (void*) name;
------------------
| | 60| 317k|#define VECTOR(v) ((v).stor_begin)
------------------
128| |
129| | /* line number */
130| 317k| VECTOR(t->lines)[0] = line;
------------------
| | 60| 317k|#define VECTOR(v) ((v).stor_begin)
------------------
131| |
132| | /* types */
133| 317k| VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_TREE;
------------------
| | 60| 317k|#define VECTOR(v) ((v).stor_begin)
------------------
134| |
135| | /* children */
136| 317k| VECTOR(t->children)[0] = value;
------------------
| | 60| 317k|#define VECTOR(v) ((v).stor_begin)
------------------
137| |
138| 317k| IGRAPH_FINALLY_CLEAN(4);
139| 317k| return IGRAPH_SUCCESS;
140| |
141| 317k|}
igraph_gml_tree_mergedest:
153| 935k|igraph_error_t igraph_gml_tree_mergedest(igraph_gml_tree_t *t1, igraph_gml_tree_t *t2) {
154| 935k| igraph_int_t i, n = igraph_vector_ptr_size(&t2->children);
155| |
156| 1.87M| for (i = 0; i < n; i++) {
------------------
| Branch (156:17): [True: 935k, False: 935k]
------------------
157| 935k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t1->names, VECTOR(t2->names)[i]));
------------------
| | 656| 935k| do { \
| | 657| 935k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 935k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 935k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 935k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 935k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 935k]
| | ------------------
------------------
158| 935k| IGRAPH_CHECK(igraph_vector_char_push_back(&t1->types, VECTOR(t2->types)[i]));
------------------
| | 656| 935k| do { \
| | 657| 935k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 935k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 935k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 935k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 935k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 935k]
| | ------------------
------------------
159| 935k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t1->children, VECTOR(t2->children)[i]));
------------------
| | 656| 935k| do { \
| | 657| 935k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 935k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 935k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 935k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 935k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 935k]
| | ------------------
------------------
160| 935k| IGRAPH_CHECK(igraph_vector_int_push_back(&t1->lines, VECTOR(t2->lines)[i]));
------------------
| | 656| 935k| do { \
| | 657| 935k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 935k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 935k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 935k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 935k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 935k]
| | ------------------
------------------
161| 935k| }
162| |
163| 935k| igraph_vector_ptr_destroy(&t2->names);
164| 935k| igraph_vector_char_destroy(&t2->types);
165| 935k| igraph_vector_ptr_destroy(&t2->children);
166| 935k| igraph_vector_int_destroy(&t2->lines);
167| |
168| 935k| return IGRAPH_SUCCESS;
169| 935k|}
igraph_gml_tree_destroy:
171| 320k|void igraph_gml_tree_destroy(igraph_gml_tree_t *t) {
172| |
173| 320k| igraph_int_t i, n = igraph_vector_ptr_size(&t->children);
174| 1.57M| for (i = 0; i < n; i++) {
------------------
| Branch (174:17): [True: 1.25M, False: 320k]
------------------
175| 1.25M| igraph_i_gml_tree_type_t type = (igraph_i_gml_tree_type_t) VECTOR(t->types)[i];
------------------
| | 60| 1.25M|#define VECTOR(v) ((v).stor_begin)
------------------
176| 1.25M| switch (type) {
------------------
| Branch (176:17): [True: 1.25M, False: 0]
------------------
177| 317k| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (177:9): [True: 317k, False: 939k]
------------------
178| 317k| igraph_gml_tree_destroy(VECTOR(t->children)[i]);
------------------
| | 60| 317k|#define VECTOR(v) ((v).stor_begin)
------------------
179| 317k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 317k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
180| 317k| break;
181| 614k| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (181:9): [True: 614k, False: 642k]
------------------
182| 614k| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 614k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
183| 614k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 614k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
184| 614k| break;
185| 954| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (185:9): [True: 954, False: 1.25M]
------------------
186| 954| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 954|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
187| 954| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 954|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
188| 954| break;
189| 323k| case IGRAPH_I_GML_TREE_STRING:
------------------
| Branch (189:9): [True: 323k, False: 932k]
------------------
190| 323k| IGRAPH_FREE(VECTOR(t->children)[i]);
------------------
| | 36| 323k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
191| 323k| IGRAPH_FREE(VECTOR(t->names)[i]);
------------------
| | 36| 323k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
192| 323k| break;
193| 0| case IGRAPH_I_GML_TREE_DELETED:
------------------
| Branch (193:9): [True: 0, False: 1.25M]
------------------
194| 0| break;
195| 1.25M| }
196| 1.25M| }
197| 320k| igraph_vector_ptr_destroy(&t->names);
198| 320k| igraph_vector_char_destroy(&t->types);
199| 320k| igraph_vector_ptr_destroy(&t->children);
200| 320k| igraph_vector_int_destroy(&t->lines);
201| | IGRAPH_FREE(t);
------------------
| | 36| 320k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
202| 320k|}
igraph_gml_tree_length:
204| 3.12M|igraph_int_t igraph_gml_tree_length(const igraph_gml_tree_t *t) {
205| 3.12M| return igraph_vector_ptr_size(&t->names);
206| 3.12M|}
igraph_gml_tree_find:
210| 601k|) {
211| 601k| igraph_int_t size = igraph_vector_ptr_size(&t->names);
212| 892k| while ( from < size && (! VECTOR(t->names)[from] ||
------------------
| | 60| 892k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (212:13): [True: 892k, False: 0]
| Branch (212:29): [True: 0, False: 892k]
------------------
213| 892k| strcmp(VECTOR(t->names)[from], name)) ) {
------------------
| | 60| 892k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (213:29): [True: 291k, False: 601k]
------------------
214| 291k| from++;
215| 291k| }
216| |
217| 601k| if (from == size) {
------------------
| Branch (217:9): [True: 0, False: 601k]
------------------
218| 0| from = -1;
219| 0| }
220| 601k| return from;
221| 601k|}
igraph_gml_tree_type:
234| 1.62M|igraph_i_gml_tree_type_t igraph_gml_tree_type(const igraph_gml_tree_t *t, igraph_int_t pos) {
235| 1.62M| return (igraph_i_gml_tree_type_t) VECTOR(t->types)[pos];
------------------
| | 60| 1.62M|#define VECTOR(v) ((v).stor_begin)
------------------
236| 1.62M|}
igraph_gml_tree_name:
238| 2.49M|const char *igraph_gml_tree_name(const igraph_gml_tree_t *t, igraph_int_t pos) {
239| 2.49M| return VECTOR(t->names)[pos];
------------------
| | 60| 2.49M|#define VECTOR(v) ((v).stor_begin)
------------------
240| 2.49M|}
igraph_gml_tree_get_integer:
247| 680k| igraph_int_t pos) {
248| 680k| igraph_int_t *i = VECTOR(t->children)[pos];
------------------
| | 60| 680k|#define VECTOR(v) ((v).stor_begin)
------------------
249| 680k| return *i;
250| 680k|}
igraph_gml_tree_get_real:
253| 954| igraph_int_t pos) {
254| 954| igraph_real_t *d = VECTOR(t->children)[pos];
------------------
| | 60| 954|#define VECTOR(v) ((v).stor_begin)
------------------
255| 954| return *d;
256| 954|}
igraph_gml_tree_get_string:
259| 320k| igraph_int_t pos) {
260| 320k| const char *s = VECTOR(t->children)[pos];
------------------
| | 60| 320k|#define VECTOR(v) ((v).stor_begin)
------------------
261| 320k| return s;
262| 320k|}
igraph_gml_tree_get_tree:
265| 631k| igraph_int_t pos) {
266| 631k| igraph_gml_tree_t *tree = VECTOR(t->children)[pos];
------------------
| | 60| 631k|#define VECTOR(v) ((v).stor_begin)
------------------
267| 631k| return tree;
268| 631k|}
igraph_i_gml_parsedata_init:
212| 3.57k|igraph_error_t igraph_i_gml_parsedata_init(igraph_i_gml_parsedata_t *context) {
213| 3.57k| context->depth = 0;
214| 3.57k| context->scanner = NULL;
215| 3.57k| context->tree = NULL;
216| 3.57k| context->errmsg[0] = '\0';
217| 3.57k| context->igraph_errno = IGRAPH_SUCCESS;
218| |
219| 3.57k| return IGRAPH_SUCCESS;
220| 3.57k|}
igraph_i_gml_parsedata_destroy:
222| 3.57k|void igraph_i_gml_parsedata_destroy(igraph_i_gml_parsedata_t *context) {
223| 3.57k| if (context->tree != NULL) {
------------------
| Branch (223:9): [True: 3.57k, False: 0]
------------------
224| 3.57k| igraph_gml_tree_destroy(context->tree);
225| 3.57k| context->tree = NULL;
226| 3.57k| }
227| |
228| 3.57k| if (context->scanner != NULL) {
------------------
| Branch (228:9): [True: 3.57k, False: 0]
------------------
229| 3.57k| (void) igraph_gml_yylex_destroy(context->scanner);
230| | context->scanner = NULL;
231| 3.57k| }
232| 3.57k|}
igraph_read_graph_gml:
386| 3.57k|igraph_error_t igraph_read_graph_gml(igraph_t *graph, FILE *instream) {
387| |
388| 3.57k| igraph_int_t i;
389| 3.57k| igraph_int_t no_of_nodes = 0, no_of_edges = 0;
390| 3.57k| igraph_int_t node_no;
391| 3.57k| igraph_trie_t trie;
392| 3.57k| igraph_vector_int_t edges;
393| 3.57k| igraph_bool_t directed = IGRAPH_UNDIRECTED;
394| 3.57k| igraph_bool_t has_directed = false;
395| 3.57k| igraph_gml_tree_t *gtree;
396| 3.57k| igraph_int_t gidx;
397| 3.57k| igraph_trie_t vattrnames;
398| 3.57k| igraph_trie_t eattrnames;
399| 3.57k| igraph_trie_t gattrnames;
400| 3.57k| igraph_attribute_record_list_t gattrs, vattrs, eattrs;
401| 3.57k| igraph_attribute_record_list_t *attrs[3];
402| 3.57k| igraph_int_t edgeptr = 0;
403| 3.57k| igraph_i_gml_parsedata_t context;
404| 3.57k| igraph_bool_t entity_warned = false; /* used to warn at most once about unsupported entities */
405| |
406| 3.57k| attrs[0] = &gattrs; attrs[1] = &vattrs; attrs[2] = &eattrs;
407| |
408| 3.57k| IGRAPH_CHECK(igraph_i_gml_parsedata_init(&context));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
409| 3.57k| IGRAPH_FINALLY(igraph_i_gml_parsedata_destroy, &context);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
410| |
411| 3.57k| igraph_gml_yylex_init_extra(&context, &context.scanner);
412| |
413| 3.57k| igraph_gml_yyset_in(instream, context.scanner);
414| |
415| | /* Protect 'context' from being destroyed before returning from yyparse() */
416| 3.57k| IGRAPH_FINALLY_ENTER();
417| 3.57k| int err = igraph_gml_yyparse(&context);
418| 3.57k| IGRAPH_FINALLY_EXIT();
419| 3.57k| switch (err) {
420| 3.57k| case 0: /* success */
------------------
| Branch (420:5): [True: 3.57k, False: 0]
------------------
421| 3.57k| break;
422| 0| case 1: /* parse error */
------------------
| Branch (422:5): [True: 0, False: 3.57k]
------------------
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.57k]
------------------
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.57k]
------------------
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.57k| }
442| |
443| | /* Check version, if present, integer and not '1' then ignored */
444| 3.57k| i = igraph_gml_tree_find(context.tree, "Version", 0);
445| 3.57k| if (i >= 0 &&
------------------
| Branch (445:9): [True: 3.57k, False: 0]
------------------
446| 3.57k| igraph_gml_tree_type(context.tree, i) == IGRAPH_I_GML_TREE_INTEGER &&
------------------
| Branch (446:9): [True: 3.57k, False: 0]
------------------
447| 3.57k| igraph_gml_tree_get_integer(context.tree, i) != 1) {
------------------
| Branch (447:9): [True: 0, False: 3.57k]
------------------
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.57k| gidx = igraph_gml_tree_find(context.tree, "graph", 0);
455| 3.57k| if (gidx == -1) {
------------------
| Branch (455:9): [True: 0, False: 3.57k]
------------------
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.57k| if (igraph_gml_tree_type(context.tree, gidx) !=
------------------
| Branch (458:9): [True: 0, False: 3.57k]
------------------
459| 3.57k| 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.57k| gtree = igraph_gml_tree_get_tree(context.tree, gidx);
464| |
465| 3.57k| IGRAPH_CHECK(igraph_attribute_record_list_init(&gattrs, 0));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
466| 3.57k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &gattrs);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
467| 3.57k| IGRAPH_CHECK(igraph_attribute_record_list_init(&vattrs, 0));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
468| 3.57k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &vattrs);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
469| 3.57k| IGRAPH_CHECK(igraph_attribute_record_list_init(&eattrs, 0));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
470| 3.57k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &eattrs);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
471| |
472| 3.57k| IGRAPH_TRIE_INIT_FINALLY(&trie, 0);
------------------
| | 55| 3.57k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 56| 3.57k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.57k]
| | ------------------
------------------
473| 3.57k| IGRAPH_TRIE_INIT_FINALLY(&vattrnames, 0);
------------------
| | 55| 3.57k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 56| 3.57k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.57k]
| | ------------------
------------------
474| 3.57k| IGRAPH_TRIE_INIT_FINALLY(&eattrnames, 0);
------------------
| | 55| 3.57k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 56| 3.57k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.57k]
| | ------------------
------------------
475| 3.57k| IGRAPH_TRIE_INIT_FINALLY(&gattrnames, 0);
------------------
| | 55| 3.57k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 56| 3.57k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.57k]
| | ------------------
------------------
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.57k| node_no = 0;
494| 321k| for (i = 0; i < igraph_gml_tree_length(gtree); i++) {
------------------
| Branch (494:17): [True: 318k, False: 3.57k]
------------------
495| 318k| const char *name = igraph_gml_tree_name(gtree, i);
496| 318k| if (!strcmp(name, "node")) {
------------------
| Branch (496:13): [True: 33.2k, False: 284k]
------------------
497| 33.2k| igraph_gml_tree_t *node;
498| 33.2k| igraph_bool_t hasid;
499| 33.2k| node_no++;
500| 33.2k| no_of_nodes++;
501| 33.2k| if (igraph_gml_tree_type(gtree, i) != IGRAPH_I_GML_TREE_TREE) {
------------------
| Branch (501:17): [True: 0, False: 33.2k]
------------------
502| 0| IGRAPH_ERRORF("'node' is not a list in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
503| 0| igraph_gml_tree_line(gtree, i));
504| 0| }
505| 33.2k| node = igraph_gml_tree_get_tree(gtree, i);
506| 33.2k| hasid = false;
507| 84.3k| for (igraph_int_t j = 0; j < igraph_gml_tree_length(node); j++) {
------------------
| Branch (507:38): [True: 51.1k, False: 33.2k]
------------------
508| 51.1k| const char *name = igraph_gml_tree_name(node, j);
509| 51.1k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, j);
510| 51.1k| IGRAPH_CHECK(create_or_update_attribute(name, type, &vattrnames, &vattrs));
------------------
| | 656| 51.1k| do { \
| | 657| 51.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.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| 51.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.1k]
| | ------------------
------------------
511| | /* check id */
512| 51.1k| if (!strcmp(name, "id")) {
------------------
| Branch (512:21): [True: 33.2k, False: 17.8k]
------------------
513| 33.2k| igraph_int_t id, trie_id;
514| 33.2k| igraph_int_t trie_size = igraph_trie_size(&trie);
515| 33.2k| if (hasid) {
------------------
| Branch (515:25): [True: 0, False: 33.2k]
------------------
516| | /* A 'node' must not have more than one 'id' field.
517| | * This error cannot be relaxed into a warning because all ids we find are
518| | * added to the trie, and eventually converted to igraph vertex ids. */
519| 0| IGRAPH_ERRORF("Node has multiple 'id' fields in GML file, line %" IGRAPH_PRId ".",
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
520| 0| IGRAPH_PARSEERROR,
521| 0| igraph_gml_tree_line(node, j));
522| 0| }
523| 33.2k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (523:25): [True: 0, False: 33.2k]
------------------
524| 0| IGRAPH_ERRORF("Non-integer node id in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
525| 0| igraph_gml_tree_line(node, j));
526| 0| }
527| 33.2k| id = igraph_gml_tree_get_integer(node, j);
528| 33.2k| IGRAPH_CHECK(igraph_trie_get(&trie, strid(id, ""), &trie_id));
------------------
| | 656| 33.2k| do { \
| | 657| 33.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 33.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 33.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33.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| 33.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 33.2k]
| | ------------------
------------------
529| 33.2k| if (trie_id != trie_size) {
------------------
| Branch (529:25): [True: 0, False: 33.2k]
------------------
530| | /* This id has already been seen in a previous node. */
531| 0| IGRAPH_ERRORF("Duplicate node id in GML file, line %" IGRAPH_PRId ".", IGRAPH_PARSEERROR,
------------------
| | 464| 0| do { \
| | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 0| igraph_errno, __VA_ARGS__) ; \
| | 467| 0| return igraph_errno; \
| | 468| 0| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
532| 0| igraph_gml_tree_line(node, j));
533| 0| }
534| 33.2k| hasid = true;
535| 33.2k| }
536| 51.1k| }
537| 33.2k| if (!hasid) {
------------------
| Branch (537:17): [True: 0, False: 33.2k]
------------------
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| 284k| } else if (!strcmp(name, "edge")) {
------------------
| Branch (543:20): [True: 280k, False: 4.36k]
------------------
544| 280k| igraph_gml_tree_t *edge;
545| 280k| igraph_bool_t has_source = false, has_target = false;
546| 280k| no_of_edges++;
547| 280k| if (igraph_gml_tree_type(gtree, i) != IGRAPH_I_GML_TREE_TREE) {
------------------
| Branch (547:17): [True: 0, False: 280k]
------------------
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| 280k| edge = igraph_gml_tree_get_tree(gtree, i);
552| 1.15M| for (igraph_int_t j = 0; j < igraph_gml_tree_length(edge); j++) {
------------------
| Branch (552:38): [True: 876k, False: 280k]
------------------
553| 876k| const char *name = igraph_gml_tree_name(edge, j);
554| 876k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(edge, j);
555| 876k| if (!strcmp(name, "source")) {
------------------
| Branch (555:21): [True: 280k, False: 595k]
------------------
556| 280k| if (has_source) {
------------------
| Branch (556:25): [True: 0, False: 280k]
------------------
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| 280k| has_source = true;
566| 280k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (566:25): [True: 0, False: 280k]
------------------
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| 595k| } else if (!strcmp(name, "target")) {
------------------
| Branch (571:28): [True: 280k, False: 315k]
------------------
572| 280k| if (has_target) {
------------------
| Branch (572:25): [True: 0, False: 280k]
------------------
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| 280k| has_target = true;
579| 280k| if (type != IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (579:25): [True: 0, False: 280k]
------------------
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| 315k| } else {
585| 315k| IGRAPH_CHECK(create_or_update_attribute(name, type, &eattrnames, &eattrs));
------------------
| | 656| 315k| do { \
| | 657| 315k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 315k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 315k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 315k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 315k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 315k]
| | ------------------
------------------
586| 315k| }
587| 876k| } /* for */
588| 280k| if (!has_source) {
------------------
| Branch (588:17): [True: 0, False: 280k]
------------------
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| 280k| if (!has_target) {
------------------
| Branch (592:17): [True: 0, False: 280k]
------------------
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| 280k| } else if (! strcmp(name, "directed")) {
------------------
| Branch (596:20): [True: 3.57k, False: 788]
------------------
597| | /* Set directedness of graph. */
598| 3.57k| if (has_directed) {
------------------
| Branch (598:17): [True: 0, False: 3.57k]
------------------
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.57k| if (igraph_gml_tree_type(gtree, i) == IGRAPH_I_GML_TREE_INTEGER) {
------------------
| Branch (604:17): [True: 3.57k, False: 0]
------------------
605| 3.57k| igraph_int_t dir = igraph_gml_tree_get_integer(gtree, i);
606| 3.57k| if (dir != 0 && dir != 1) {
------------------
| Branch (606:21): [True: 134, False: 3.44k]
| Branch (606:33): [True: 0, False: 134]
------------------
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.57k| if (dir) {
------------------
| Branch (611:21): [True: 134, False: 3.44k]
------------------
612| 134| directed = IGRAPH_DIRECTED;
613| 134| }
614| 3.57k| has_directed = true;
615| 3.57k| } 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.57k| } else {
620| | /* Add the rest of items as graph attributes. */
621| 788| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(gtree, i);
622| 788| IGRAPH_CHECK(create_or_update_attribute(name, type, &gattrnames, &gattrs));
------------------
| | 656| 788| do { \
| | 657| 788| igraph_error_t igraph_i_ret = (expr); \
| | 658| 788| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 788| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 788]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 788| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 788]
| | ------------------
------------------
623| 788| }
624| 318k| }
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.57k| IGRAPH_ASSERT(igraph_trie_size(&trie) == no_of_nodes);
------------------
| | 924| 3.57k| do { \
| | 925| 3.57k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 3.57k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 3.57k]
| | ------------------
------------------
630| |
631| | /* Now we allocate the vectors and strvectors for the attributes */
632| 3.57k| IGRAPH_CHECK(allocate_attributes(&vattrs, no_of_nodes, "vertex"));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
633| 3.57k| IGRAPH_CHECK(allocate_attributes(&eattrs, no_of_edges, "edge"));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
634| 3.57k| IGRAPH_CHECK(allocate_attributes(&gattrs, 1, "graph"));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
635| |
636| | /* Add edges, edge attributes and vertex attributes */
637| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, no_of_edges * 2);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
638| 3.57k| node_no = 0;
639| 321k| for (i = 0; i < igraph_gml_tree_length(gtree); i++) {
------------------
| Branch (639:17): [True: 318k, False: 3.57k]
------------------
640| 318k| const char *name;
641| 318k| name = igraph_gml_tree_name(gtree, i);
642| 318k| if (!strcmp(name, "node")) {
------------------
| Branch (642:13): [True: 33.2k, False: 284k]
------------------
643| 33.2k| igraph_gml_tree_t *node = igraph_gml_tree_get_tree(gtree, i);
644| 33.2k| igraph_int_t iidx = igraph_gml_tree_find(node, "id", 0);
645| 33.2k| igraph_int_t trie_id;
646| 33.2k| const char *sid;
647| 33.2k| node_no++;
648| 33.2k| if (iidx < 0) {
------------------
| Branch (648:17): [True: 0, False: 33.2k]
------------------
649| | /* Isolated node with no id field, use n-prefixed generated id */
650| 0| sid = strid(node_no, "n");
651| 33.2k| } else {
652| 33.2k| sid = strid(igraph_gml_tree_get_integer(node, iidx), "");
653| 33.2k| }
654| 33.2k| IGRAPH_CHECK(igraph_trie_get(&trie, sid, &trie_id));
------------------
| | 656| 33.2k| do { \
| | 657| 33.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 33.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 33.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33.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| 33.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 33.2k]
| | ------------------
------------------
655| 84.3k| for (igraph_int_t j = 0; j < igraph_gml_tree_length(node); j++) {
------------------
| Branch (655:38): [True: 51.1k, False: 33.2k]
------------------
656| 51.1k| const char *aname = igraph_gml_tree_name(node, j);
657| 51.1k| igraph_attribute_record_t *atrec;
658| 51.1k| igraph_attribute_type_t type;
659| 51.1k| igraph_int_t ai;
660| 51.1k| IGRAPH_CHECK(igraph_trie_get(&vattrnames, aname, &ai));
------------------
| | 656| 51.1k| do { \
| | 657| 51.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.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| 51.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.1k]
| | ------------------
------------------
661| 51.1k| atrec = igraph_attribute_record_list_get_ptr(&vattrs, ai);
662| 51.1k| type = atrec->type;
663| 51.1k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (663:21): [True: 39.9k, False: 11.1k]
------------------
664| 39.9k| VECTOR(*atrec->value.as_vector)[trie_id] = igraph_i_gml_toreal(node, j);
------------------
| | 60| 39.9k|#define VECTOR(v) ((v).stor_begin)
------------------
665| 39.9k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (665:28): [True: 11.1k, False: 0]
------------------
666| 11.1k| igraph_strvector_t *v = atrec->value.as_strvector;
667| 11.1k| const char *value = igraph_i_gml_tostring(node, j);
668| 11.1k| if (needs_coding(value)) {
------------------
| Branch (668:25): [True: 5.22k, False: 5.96k]
------------------
669| 5.22k| char *value_decoded;
670| 5.22k| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 656| 5.22k| do { \
| | 657| 5.22k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.22k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.22k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.22k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.22k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.22k]
| | ------------------
------------------
671| 5.22k| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 5.22k| do { \
| | 604| 5.22k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.22k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.22k| * incorrect destructor function with the pointer */ \
| | 607| 5.22k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.22k]
| | ------------------
| | 608| 5.22k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.22k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.22k]
| | ------------------
------------------
672| 5.22k| IGRAPH_CHECK(igraph_strvector_set(v, trie_id, value_decoded));
------------------
| | 656| 5.22k| do { \
| | 657| 5.22k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.22k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.22k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.22k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.22k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.22k]
| | ------------------
------------------
673| 5.22k| IGRAPH_FREE(value_decoded);
------------------
| | 36| 5.22k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
674| 5.22k| IGRAPH_FINALLY_CLEAN(1);
675| 5.96k| } else {
676| 5.96k| IGRAPH_CHECK(igraph_strvector_set(v, trie_id, value));
------------------
| | 656| 5.96k| do { \
| | 657| 5.96k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.96k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.96k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.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| 5.96k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.96k]
| | ------------------
------------------
677| 5.96k| }
678| 11.1k| } else {
679| | /* Ignored composite attribute */
680| 0| }
681| 51.1k| }
682| 284k| } else if (!strcmp(name, "edge")) {
------------------
| Branch (682:20): [True: 280k, False: 4.36k]
------------------
683| 280k| igraph_gml_tree_t *edge;
684| 280k| igraph_int_t from, to, fromidx = 0, toidx = 0;
685| 280k| edge = igraph_gml_tree_get_tree(gtree, i);
686| 1.15M| for (igraph_int_t j = 0; j < igraph_gml_tree_length(edge); j++) {
------------------
| Branch (686:38): [True: 876k, False: 280k]
------------------
687| 876k| const char *aname = igraph_gml_tree_name(edge, j);
688| 876k| if (!strcmp(aname, "source")) {
------------------
| Branch (688:21): [True: 280k, False: 595k]
------------------
689| 280k| fromidx = igraph_gml_tree_find(edge, "source", 0);
690| 595k| } else if (!strcmp(aname, "target")) {
------------------
| Branch (690:28): [True: 280k, False: 315k]
------------------
691| 280k| toidx = igraph_gml_tree_find(edge, "target", 0);
692| 315k| } else {
693| 315k| igraph_int_t edgeid = edgeptr / 2;
694| 315k| igraph_int_t ai;
695| 315k| igraph_attribute_record_t *atrec;
696| 315k| igraph_attribute_type_t type;
697| 315k| IGRAPH_CHECK(igraph_trie_get(&eattrnames, aname, &ai));
------------------
| | 656| 315k| do { \
| | 657| 315k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 315k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 315k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 315k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 315k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 315k]
| | ------------------
------------------
698| 315k| atrec = igraph_attribute_record_list_get_ptr(&eattrs, ai);
699| 315k| type = atrec->type;
700| 315k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (700:25): [True: 6.30k, False: 308k]
------------------
701| 6.30k| VECTOR(*atrec->value.as_vector)[edgeid] = igraph_i_gml_toreal(edge, j);
------------------
| | 60| 6.30k|#define VECTOR(v) ((v).stor_begin)
------------------
702| 308k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (702:32): [True: 308k, False: 0]
------------------
703| 308k| igraph_strvector_t *v = atrec->value.as_strvector;
704| 308k| const char *value = igraph_i_gml_tostring(edge, j);
705| 308k| if (needs_coding(value)) {
------------------
| Branch (705:29): [True: 2.48k, False: 306k]
------------------
706| 2.48k| char *value_decoded;
707| 2.48k| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 656| 2.48k| do { \
| | 657| 2.48k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.48k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.48k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.48k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.48k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.48k]
| | ------------------
------------------
708| 2.48k| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 2.48k| do { \
| | 604| 2.48k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.48k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.48k| * incorrect destructor function with the pointer */ \
| | 607| 2.48k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.48k]
| | ------------------
| | 608| 2.48k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.48k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.48k]
| | ------------------
------------------
709| 2.48k| IGRAPH_CHECK(igraph_strvector_set(v, edgeid, value_decoded));
------------------
| | 656| 2.48k| do { \
| | 657| 2.48k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.48k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.48k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.48k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.48k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.48k]
| | ------------------
------------------
710| 2.48k| IGRAPH_FREE(value_decoded);
------------------
| | 36| 2.48k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
711| 2.48k| IGRAPH_FINALLY_CLEAN(1);
712| 306k| } else {
713| 306k| IGRAPH_CHECK(igraph_strvector_set(v, edgeid, value));
------------------
| | 656| 306k| do { \
| | 657| 306k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 306k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 306k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 306k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 306k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 306k]
| | ------------------
------------------
714| 306k| }
715| 308k| } else {
716| | /* Ignored composite attribute */
717| 0| }
718| 315k| }
719| 876k| }
720| 280k| from = igraph_gml_tree_get_integer(edge, fromidx);
721| 280k| to = igraph_gml_tree_get_integer(edge, toidx);
722| 280k| IGRAPH_CHECK(igraph_trie_check(&trie, strid(from, ""), &from));
------------------
| | 656| 280k| do { \
| | 657| 280k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 280k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 280k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 280k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 280k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 280k]
| | ------------------
------------------
723| 280k| if (from < 0) {
------------------
| Branch (723:17): [True: 0, False: 280k]
------------------
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| 280k| IGRAPH_CHECK(igraph_trie_check(&trie, strid(to, ""), &to));
------------------
| | 656| 280k| do { \
| | 657| 280k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 280k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 280k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 280k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 280k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 280k]
| | ------------------
------------------
728| 280k| if (to < 0) {
------------------
| Branch (728:17): [True: 0, False: 280k]
------------------
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| 280k| VECTOR(edges)[edgeptr++] = from;
------------------
| | 60| 280k|#define VECTOR(v) ((v).stor_begin)
------------------
733| 280k| VECTOR(edges)[edgeptr++] = to;
------------------
| | 60| 280k|#define VECTOR(v) ((v).stor_begin)
------------------
734| 280k| } else if (! strcmp(name, "directed")) {
------------------
| Branch (734:20): [True: 3.57k, False: 788]
------------------
735| | /* Nothing to do for 'directed' field, already handled earlier. */
736| 3.57k| } else {
737| | /* Set the rest as graph attributes */
738| 788| igraph_int_t ai;
739| 788| igraph_attribute_record_t *atrec;
740| 788| igraph_attribute_type_t type;
741| 788| IGRAPH_CHECK(igraph_trie_get(&gattrnames, name, &ai));
------------------
| | 656| 788| do { \
| | 657| 788| igraph_error_t igraph_i_ret = (expr); \
| | 658| 788| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 788| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 788]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 788| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 788]
| | ------------------
------------------
742| 788| atrec = igraph_attribute_record_list_get_ptr(&gattrs, ai);
743| 788| type = atrec->type;
744| 788| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (744:17): [True: 153, False: 635]
------------------
745| 153| VECTOR(*atrec->value.as_vector)[0] = igraph_i_gml_toreal(gtree, i);
------------------
| | 60| 153|#define VECTOR(v) ((v).stor_begin)
------------------
746| 635| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (746:24): [True: 635, False: 0]
------------------
747| 635| igraph_strvector_t *v = atrec->value.as_strvector;
748| 635| const char *value = igraph_i_gml_tostring(gtree, i);
749| 635| if (needs_coding(value)) {
------------------
| Branch (749:21): [True: 74, False: 561]
------------------
750| 74| char *value_decoded;
751| 74| IGRAPH_CHECK(entity_decode(value, &value_decoded, &entity_warned));
------------------
| | 656| 74| do { \
| | 657| 74| igraph_error_t igraph_i_ret = (expr); \
| | 658| 74| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 74| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 74]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 74| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 74]
| | ------------------
------------------
752| 74| IGRAPH_FINALLY(igraph_free, value_decoded);
------------------
| | 603| 74| do { \
| | 604| 74| /* the following branch makes the compiler check the compatibility of \
| | 605| 74| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 74| * incorrect destructor function with the pointer */ \
| | 607| 74| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 74]
| | ------------------
| | 608| 74| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 74| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 74]
| | ------------------
------------------
753| 74| IGRAPH_CHECK(igraph_strvector_set(v, 0, value_decoded));
------------------
| | 656| 74| do { \
| | 657| 74| igraph_error_t igraph_i_ret = (expr); \
| | 658| 74| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 74| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 74]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 74| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 74]
| | ------------------
------------------
754| 74| IGRAPH_FREE(value_decoded);
------------------
| | 36| 74|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
755| 74| IGRAPH_FINALLY_CLEAN(1);
756| 561| } else {
757| 561| IGRAPH_CHECK(igraph_strvector_set(v, 0, value));
------------------
| | 656| 561| do { \
| | 657| 561| igraph_error_t igraph_i_ret = (expr); \
| | 658| 561| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 561| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 561]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 561| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 561]
| | ------------------
------------------
758| 561| }
759| 635| } else {
760| | /* Ignored composite attribute */
761| 0| }
762| 788| }
763| 318k| }
764| |
765| | /* Remove composite attributes that we cannot represent in igraph */
766| 3.57k| IGRAPH_CHECK(prune_unknown_attributes(&vattrs));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
767| 3.57k| IGRAPH_CHECK(prune_unknown_attributes(&eattrs));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
768| 3.57k| IGRAPH_CHECK(prune_unknown_attributes(&gattrs));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
769| |
770| 3.57k| igraph_trie_destroy(&trie);
771| 3.57k| igraph_trie_destroy(&gattrnames);
772| 3.57k| igraph_trie_destroy(&vattrnames);
773| 3.57k| igraph_trie_destroy(&eattrnames);
774| 3.57k| IGRAPH_FINALLY_CLEAN(4);
775| |
776| 3.57k| IGRAPH_CHECK(igraph_empty_attrs(graph, 0, directed, &gattrs));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
777| 3.57k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
778| 3.57k| IGRAPH_CHECK(igraph_add_vertices(graph, no_of_nodes, &vattrs));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
779| 3.57k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, &eattrs));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
780| 3.57k| IGRAPH_FINALLY_CLEAN(1); /* do not destroy 'graph', just pop it from the stack */
781| |
782| 3.57k| igraph_vector_int_destroy(&edges);
783| 3.57k| igraph_attribute_record_list_destroy(&eattrs);
784| 3.57k| igraph_attribute_record_list_destroy(&vattrs);
785| 3.57k| igraph_attribute_record_list_destroy(&gattrs);
786| 3.57k| igraph_i_gml_parsedata_destroy(&context);
787| 3.57k| IGRAPH_FINALLY_CLEAN(5);
788| |
789| 3.57k| return IGRAPH_SUCCESS;
790| 3.57k|}
igraph_write_graph_gml:
932| 3.57k| const igraph_vector_t *id, const char *creator) {
933| 3.57k| igraph_strvector_t gnames, vnames, enames; /* attribute names */
934| 3.57k| igraph_vector_int_t gtypes, vtypes, etypes; /* attribute types */
935| 3.57k| igraph_int_t gattr_no, vattr_no, eattr_no; /* attribute counts */
936| 3.57k| igraph_vector_t numv;
937| 3.57k| igraph_strvector_t strv;
938| 3.57k| igraph_vector_bool_t boolv;
939| 3.57k| igraph_int_t i;
940| 3.57k| igraph_int_t no_of_nodes = igraph_vcount(graph);
941| 3.57k| 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.57k| igraph_vector_int_t warning_shown;
946| |
947| 3.57k| igraph_vector_t v_myid;
948| 3.57k| const igraph_vector_t *myid = id;
949| |
950| | /* Creator line */
951| 3.57k| if (creator == NULL) {
------------------
| Branch (951:9): [True: 0, False: 3.57k]
------------------
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.57k| } else if (creator[0] == '\0') {
------------------
| Branch (959:16): [True: 0, False: 3.57k]
------------------
960| | /* creator == "", omit Creator line */
961| 3.57k| } else {
962| 3.57k| if (needs_coding(creator)) {
------------------
| Branch (962:13): [True: 0, False: 3.57k]
------------------
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.57k| } else {
972| 3.57k| CHECK(fprintf(outstream,
------------------
| | 848| 3.57k|#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.57k]
| | | Branch (848:116): [Folded, False: 3.57k]
| | ------------------
------------------
973| 3.57k| "Creator \"%s\"\n",
974| 3.57k| creator));
975| 3.57k| }
976| 3.57k| }
977| |
978| | /* Version line */
979| 3.57k| CHECK(fprintf(outstream, "Version 1\n"));
------------------
| | 848| 3.57k|#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.57k]
| | | Branch (848:116): [Folded, False: 3.57k]
| | ------------------
------------------
980| |
981| | /* The graph */
982| 3.57k| CHECK(fprintf(outstream, "graph\n[\n"));
------------------
| | 848| 3.57k|#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.57k]
| | | Branch (848:116): [Folded, False: 3.57k]
| | ------------------
------------------
983| |
984| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
985| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
986| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
987| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
988| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
989| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
990| 3.57k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
991| 3.57k| &gnames, >ypes,
992| 3.57k| &vnames, &vtypes,
993| 3.57k| &enames, &etypes));
994| 3.57k| gattr_no = igraph_vector_int_size(>ypes);
995| 3.57k| vattr_no = igraph_vector_int_size(&vtypes);
996| 3.57k| eattr_no = igraph_vector_int_size(&etypes);
997| |
998| 3.57k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.57k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 105| 3.57k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.57k]
| | ------------------
------------------
999| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
1000| 3.57k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);
------------------
| | 109| 3.57k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 110| 3.57k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.57k]
| | ------------------
------------------
1001| |
1002| | /* Check whether there is an 'id' node attribute if the supplied is 0 */
1003| 3.57k| if (!id) {
------------------
| Branch (1003:9): [True: 3.57k, False: 0]
------------------
1004| 3.57k| igraph_bool_t found = false;
1005| 8.93k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1005:21): [True: 5.40k, False: 3.53k]
------------------
1006| 5.40k| const char *n = igraph_strvector_get(&vnames, i);
1007| 5.40k| if (!strcmp(n, "id") && VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 3.56k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1007:17): [True: 3.56k, False: 1.83k]
| Branch (1007:37): [True: 46, False: 3.51k]
------------------
1008| 46| found = true; break;
1009| 46| }
1010| 5.40k| }
1011| 3.57k| if (found) {
------------------
| Branch (1011:13): [True: 46, False: 3.53k]
------------------
1012| 46| IGRAPH_VECTOR_INIT_FINALLY(&v_myid, no_of_nodes);
------------------
| | 104| 46| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 46| do { \
| | | | 657| 46| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 46| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 46| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 46]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 46| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 46]
| | | | ------------------
| | ------------------
| | 105| 46| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 46| do { \
| | | | 604| 46| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 46| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 46| * incorrect destructor function with the pointer */ \
| | | | 607| 46| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 46]
| | | | ------------------
| | | | 608| 46| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 46| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 46]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 46]
| | ------------------
------------------
1013| 46| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, "id",
------------------
| | 656| 46| do { \
| | 657| 46| igraph_error_t igraph_i_ret = (expr); \
| | 658| 46| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 46| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 46]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 46| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 46]
| | ------------------
------------------
1014| 46| igraph_vss_all(),
1015| 46| &v_myid));
1016| 46| myid = &v_myid;
1017| 46| }
1018| 3.57k| }
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.57k| if (myid) {
------------------
| Branch (1025:9): [True: 46, False: 3.53k]
------------------
1026| 46| if (igraph_vector_size(myid) != no_of_nodes) {
------------------
| Branch (1026:13): [True: 0, False: 46]
------------------
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| 1.88k| for (i = 0; i < no_of_nodes; ++i) {
------------------
| Branch (1029:21): [True: 1.83k, False: 44]
------------------
1030| 1.83k| igraph_real_t val = VECTOR(*myid)[i];
------------------
| | 60| 1.83k|#define VECTOR(v) ((v).stor_begin)
------------------
1031| 1.83k| igraph_real_t trunc_val = trunc(val);
1032| 1.83k| if (! (val == trunc_val && igraph_i_is_real_representable_as_integer(trunc_val))) {
------------------
| Branch (1032:20): [True: 1.83k, False: 1]
| Branch (1032:40): [True: 1.83k, False: 1]
------------------
1033| 2| IGRAPH_WARNINGF("%g is not a valid integer id for GML files, ignoring all supplied ids.", val);
------------------
| | 777| 2| do { \
| | 778| 2| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 2| __VA_ARGS__); \
| | 780| 2| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 2]
| | ------------------
------------------
1034| 2| if (myid == &v_myid) {
------------------
| Branch (1034:21): [True: 2, False: 0]
------------------
1035| 2| igraph_vector_destroy(&v_myid);
1036| 2| IGRAPH_FINALLY_CLEAN(1);
1037| 2| }
1038| 2| myid = NULL;
1039| 2| break;
1040| 2| }
1041| 1.83k| }
1042| 46| }
1043| |
1044| 3.57k| if (myid) {
------------------
| Branch (1044:9): [True: 44, False: 3.53k]
------------------
1045| 44| igraph_bool_t duplicate_free;
1046| 44| IGRAPH_CHECK(igraph_i_vector_is_duplicate_free(myid, &duplicate_free));
------------------
| | 656| 44| do { \
| | 657| 44| igraph_error_t igraph_i_ret = (expr); \
| | 658| 44| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 44| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 44]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 44]
| | ------------------
------------------
1047| 44| if (! duplicate_free) {
------------------
| Branch (1047:13): [True: 33, False: 11]
------------------
1048| 33| IGRAPH_WARNING("Duplicate id values found, ignoring supplies ids.");
------------------
| | 797| 33| do { \
| | 798| 33| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 33| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 33]
| | ------------------
------------------
1049| 33| if (myid == &v_myid) {
------------------
| Branch (1049:17): [True: 33, False: 0]
------------------
1050| 33| igraph_vector_destroy(&v_myid);
1051| 33| IGRAPH_FINALLY_CLEAN(1);
1052| 33| }
1053| 33| myid = NULL;
1054| 33| }
1055| 44| }
1056| |
1057| | /* directedness */
1058| 3.57k| CHECK(fprintf(outstream, " directed %i\n", igraph_is_directed(graph) ? 1 : 0));
------------------
| | 848| 7.15k|#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: 134, False: 3.44k]
| | | Branch (848:42): [True: 0, False: 3.57k]
| | | Branch (848:116): [Folded, False: 3.57k]
| | ------------------
------------------
1059| |
1060| | /* Graph attributes first */
1061| 4.44k| for (i = 0; i < gattr_no; i++) {
------------------
| Branch (1061:17): [True: 865, False: 3.57k]
------------------
1062| 865| const char *name;
1063| 865| char *newname;
1064| 865| name = igraph_strvector_get(&gnames, i);
1065| 865| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 656| 865| do { \
| | 657| 865| igraph_error_t igraph_i_ret = (expr); \
| | 658| 865| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 865| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 865]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 865| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 865]
| | ------------------
------------------
1066| 865| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 865| do { \
| | 604| 865| /* the following branch makes the compiler check the compatibility of \
| | 605| 865| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 865| * incorrect destructor function with the pointer */ \
| | 607| 865| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 865]
| | ------------------
| | 608| 865| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 865| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 865]
| | ------------------
------------------
1067| 865| if (!strcmp(newname, "directed")|| !strcmp(newname, "edge") || !strcmp(newname, "node")) {
------------------
| Branch (1067:13): [True: 3, False: 862]
| Branch (1067:44): [True: 4, False: 858]
| Branch (1067:72): [True: 2, False: 856]
------------------
1068| 9| IGRAPH_WARNINGF("The graph attribute '%s' was ignored while writing GML format.", name);
------------------
| | 777| 9| do { \
| | 778| 9| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 9| __VA_ARGS__); \
| | 780| 9| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 9]
| | ------------------
------------------
1069| 856| } else {
1070| 856| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 856|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1070:17): [True: 86, False: 770]
------------------
1071| 86| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 86| do { \
| | 657| 86| igraph_error_t igraph_i_ret = (expr); \
| | 658| 86| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 86| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 86]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 86| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 86]
| | ------------------
------------------
1072| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1073| 86| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1073:21): [True: 18, False: 68]
------------------
1074| 18| if (! isfinite(VECTOR(numv)[0])) {
------------------
| Branch (1074:25): [True: 0, False: 18]
------------------
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| 18| CHECK(fprintf(outstream, " %s ", newname));
------------------
| | 848| 18|#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: 18]
| | | Branch (848:116): [Folded, False: 18]
| | ------------------
------------------
1079| 18| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
------------------
| | 848| 18|#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: 18]
| | | Branch (848:116): [Folded, False: 18]
| | ------------------
------------------
1080| 18| CHECK(fputc('\n', outstream));
------------------
| | 848| 18|#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: 18]
| | | Branch (848:116): [Folded, False: 18]
| | ------------------
------------------
1081| 18| }
1082| 770| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 770|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1082:24): [True: 623, False: 147]
------------------
1083| 623| const char *s;
1084| 623| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 623| do { \
| | 657| 623| igraph_error_t igraph_i_ret = (expr); \
| | 658| 623| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 623| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 623]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 623| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 623]
| | ------------------
------------------
1085| 623| s = igraph_strvector_get(&strv, 0);
1086| 623| if (needs_coding(s)) {
------------------
| Branch (1086:21): [True: 74, False: 549]
------------------
1087| 74| char *d;
1088| 74| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 74| do { \
| | 657| 74| igraph_error_t igraph_i_ret = (expr); \
| | 658| 74| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 74| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 74]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 74| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 74]
| | ------------------
------------------
1089| 74| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 74| do { \
| | 604| 74| /* the following branch makes the compiler check the compatibility of \
| | 605| 74| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 74| * incorrect destructor function with the pointer */ \
| | 607| 74| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 74]
| | ------------------
| | 608| 74| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 74| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 74]
| | ------------------
------------------
1090| 74| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 74|#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: 74]
| | | Branch (848:116): [Folded, False: 74]
| | ------------------
------------------
1091| 74| IGRAPH_FREE(d);
------------------
| | 36| 74|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1092| 74| IGRAPH_FINALLY_CLEAN(1);
1093| 549| } else {
1094| 549| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 549|#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: 549]
| | | Branch (848:116): [Folded, False: 549]
| | ------------------
------------------
1095| 549| }
1096| 623| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 147|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1096:24): [True: 147, False: 0]
------------------
1097| 147| IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
------------------
| | 656| 147| do { \
| | 657| 147| igraph_error_t igraph_i_ret = (expr); \
| | 658| 147| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 147| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 147]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 147| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 147]
| | ------------------
------------------
1098| 147| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 294|#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: 146]
| | | Branch (848:42): [True: 0, False: 147]
| | | Branch (848:116): [Folded, False: 147]
| | ------------------
------------------
1099| 147| IGRAPH_WARNING("A boolean graph attribute was converted to numeric.");
------------------
| | 797| 147| do { \
| | 798| 147| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 147| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 147]
| | ------------------
------------------
1100| 147| } 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| 856| }
1104| 865| IGRAPH_FREE(newname);
------------------
| | 36| 865|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1105| 865| IGRAPH_FINALLY_CLEAN(1);
1106| 865| }
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.57k|#define GETBIT(k, i) ((k) & (1 << i))
1111| 3.57k|#define SETBIT(k, i) ((k) |= (1 << i))
1112| 3.57k|#define WARN_ONCE(attrno, bit, warn) \
1113| 3.57k| do { \
1114| 3.57k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
1115| 3.57k| if (! GETBIT(*p, bit)) { \
1116| 3.57k| warn; \
1117| 3.57k| SETBIT(*p, bit); \
1118| 3.57k| } \
1119| 3.57k| } while (0)
1120| |
1121| |
1122| | /* Now come the vertices */
1123| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&warning_shown, vattr_no);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
1124| 36.8k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (1124:17): [True: 33.2k, False: 3.57k]
------------------
1125| 33.2k| igraph_int_t j;
1126| 33.2k| CHECK(fprintf(outstream, " node\n [\n"));
------------------
| | 848| 33.2k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 33.2k]
| | | Branch (848:116): [Folded, False: 33.2k]
| | ------------------
------------------
1127| | /* id */
1128| 33.2k| CHECK(fprintf(outstream, " id %" IGRAPH_PRId "\n", myid ? (igraph_int_t)VECTOR(*myid)[i] : i));
------------------
| | 848| 66.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: 8, False: 33.2k]
| | | Branch (848:42): [True: 0, False: 33.2k]
| | | Branch (848:116): [Folded, False: 33.2k]
| | ------------------
------------------
1129| | /* other attributes */
1130| 85.2k| for (j = 0; j < vattr_no; j++) {
------------------
| Branch (1130:21): [True: 51.9k, False: 33.2k]
------------------
1131| 51.9k| igraph_attribute_type_t type = (igraph_attribute_type_t) VECTOR(vtypes)[j];
------------------
| | 60| 51.9k|#define VECTOR(v) ((v).stor_begin)
------------------
1132| 51.9k| const char *name;
1133| 51.9k| char *newname;
1134| 51.9k| name = igraph_strvector_get(&vnames, j);
1135| 51.9k| if (!strcmp(name, "id")) {
------------------
| Branch (1135:17): [True: 32.9k, False: 18.9k]
------------------
1136| | /* No warning, the presence of this attribute is expected, and is handled specially. */
1137| 32.9k| continue;
1138| 32.9k| }
1139| 18.9k| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 656| 18.9k| do { \
| | 657| 18.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 18.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 18.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 18.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| 18.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 18.9k]
| | ------------------
------------------
1140| 18.9k| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 18.9k| do { \
| | 604| 18.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 18.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 18.9k| * incorrect destructor function with the pointer */ \
| | 607| 18.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 18.9k]
| | ------------------
| | 608| 18.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 18.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 18.9k]
| | ------------------
------------------
1141| 18.9k| if (!strcmp(newname, "id")) {
------------------
| Branch (1141:17): [True: 239, False: 18.7k]
------------------
1142| | /* In case an attribute name would conflict with 'id' only after encoding. */
1143| 239| WARN_ONCE(j, 0,
------------------
| | 1113| 239| do { \
| | 1114| 239| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 239|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 239| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 239|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 11, False: 228]
| | ------------------
| | 1116| 22| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 11]
| | ------------------
| | 1117| 11| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 11|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 11| } \
| | 1119| 239| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 239]
| | ------------------
------------------
1144| 239| 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.93k, False: 15.8k]
------------------
1147| 2.93k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name,
------------------
| | 656| 2.93k| do { \
| | 657| 2.93k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.93k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.93k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.93k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 2.93k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.93k]
| | ------------------
------------------
1148| 2.93k| igraph_vss_1(i), &numv));
1149| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1150| 2.93k| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1150:25): [True: 2.06k, False: 870]
------------------
1151| 2.06k| if (! isfinite(VECTOR(numv)[0])) {
------------------
| Branch (1151:29): [True: 0, False: 2.06k]
------------------
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.06k| CHECK(fprintf(outstream, " %s ", newname));
------------------
| | 848| 2.06k|#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.06k]
| | | Branch (848:116): [Folded, False: 2.06k]
| | ------------------
------------------
1157| 2.06k| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
------------------
| | 848| 2.06k|#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.06k]
| | | Branch (848:116): [Folded, False: 2.06k]
| | ------------------
------------------
1158| 2.06k| CHECK(fputc('\n', outstream));
------------------
| | 848| 2.06k|#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.06k]
| | | Branch (848:116): [Folded, False: 2.06k]
| | ------------------
------------------
1159| 2.06k| }
1160| 15.8k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (1160:28): [True: 11.1k, False: 4.62k]
------------------
1161| 11.1k| const char *s;
1162| 11.1k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name,
------------------
| | 656| 11.1k| do { \
| | 657| 11.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 11.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 11.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 11.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| 11.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 11.1k]
| | ------------------
------------------
1163| 11.1k| igraph_vss_1(i), &strv));
1164| 11.1k| s = igraph_strvector_get(&strv, 0);
1165| 11.1k| if (needs_coding(s)) {
------------------
| Branch (1165:25): [True: 5.22k, False: 5.96k]
------------------
1166| 5.22k| char *d;
1167| 5.22k| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 5.22k| do { \
| | 657| 5.22k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.22k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.22k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.22k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.22k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.22k]
| | ------------------
------------------
1168| 5.22k| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 5.22k| do { \
| | 604| 5.22k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.22k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.22k| * incorrect destructor function with the pointer */ \
| | 607| 5.22k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.22k]
| | ------------------
| | 608| 5.22k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.22k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.22k]
| | ------------------
------------------
1169| 5.22k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 5.22k|#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.22k]
| | | Branch (848:116): [Folded, False: 5.22k]
| | ------------------
------------------
1170| 5.22k| IGRAPH_FREE(d);
------------------
| | 36| 5.22k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1171| 5.22k| IGRAPH_FINALLY_CLEAN(1);
1172| 5.96k| } else {
1173| 5.96k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 5.96k|#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.96k]
| | | Branch (848:116): [Folded, False: 5.96k]
| | ------------------
------------------
1174| 5.96k| }
1175| 11.1k| } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (1175:28): [True: 4.62k, False: 0]
------------------
1176| 4.62k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name,
------------------
| | 656| 4.62k| do { \
| | 657| 4.62k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.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| 4.62k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.62k]
| | ------------------
------------------
1177| 4.62k| igraph_vss_1(i), &boolv));
1178| 4.62k| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 9.25k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:33): [True: 20, False: 4.60k]
| | | Branch (848:42): [True: 0, False: 4.62k]
| | | Branch (848:116): [Folded, False: 4.62k]
| | ------------------
------------------
1179| 4.62k| WARN_ONCE(j, 1,
------------------
| | 1113| 4.62k| do { \
| | 1114| 4.62k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 4.62k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 4.62k| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 4.62k|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 503, False: 4.12k]
| | ------------------
| | 1116| 1.00k| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 503]
| | ------------------
| | 1117| 503| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 503|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 503| } \
| | 1119| 4.62k| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 4.62k]
| | ------------------
------------------
1180| 4.62k| IGRAPH_WARNINGF("The boolean vertex attribute '%s' was converted to numeric.", name));
1181| 4.62k| } 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| 18.9k| IGRAPH_FREE(newname);
------------------
| | 36| 18.9k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1187| 18.9k| IGRAPH_FINALLY_CLEAN(1);
1188| 18.9k| }
1189| 33.2k| CHECK(fprintf(outstream, " ]\n"));
------------------
| | 848| 33.2k|#define CHECK(cmd) do { int ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (848:42): [True: 0, False: 33.2k]
| | | Branch (848:116): [Folded, False: 33.2k]
| | ------------------
------------------
1190| 33.2k| }
1191| |
1192| | /* The edges too */
1193| 3.57k| IGRAPH_CHECK(igraph_vector_int_resize(&warning_shown, eattr_no));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
1194| 3.57k| igraph_vector_int_null(&warning_shown);
1195| 284k| for (i = 0; i < no_of_edges; i++) {
------------------
| Branch (1195:17): [True: 280k, False: 3.57k]
------------------
1196| 280k| igraph_int_t from = IGRAPH_FROM(graph, i);
------------------
| | 115| 280k|#define IGRAPH_FROM(graph,eid) ((igraph_int_t)(VECTOR((graph)->from)[(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 280k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1197| 280k| igraph_int_t to = IGRAPH_TO(graph, i);
------------------
| | 128| 280k|#define IGRAPH_TO(graph,eid) ((igraph_int_t)(VECTOR((graph)->to) [(igraph_int_t)(eid)]))
| | ------------------
| | | | 60| 280k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1198| 280k| igraph_int_t j;
1199| 280k| CHECK(fprintf(outstream, " edge\n [\n"));
------------------
| | 848| 280k|#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: 280k]
| | | Branch (848:116): [Folded, False: 280k]
| | ------------------
------------------
1200| | /* source and target */
1201| 280k| CHECK(fprintf(outstream, " source %" IGRAPH_PRId "\n",
------------------
| | 848| 561k|#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: 67, False: 280k]
| | | Branch (848:42): [True: 0, False: 280k]
| | | Branch (848:116): [Folded, False: 280k]
| | ------------------
------------------
1202| 280k| myid ? (igraph_int_t)VECTOR(*myid)[from] : from));
1203| 280k| CHECK(fprintf(outstream, " target %" IGRAPH_PRId "\n",
------------------
| | 848| 561k|#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: 67, False: 280k]
| | | Branch (848:42): [True: 0, False: 280k]
| | | Branch (848:116): [Folded, False: 280k]
| | ------------------
------------------
1204| 280k| myid ? (igraph_int_t)VECTOR(*myid)[to] : to));
1205| |
1206| | /* other attributes */
1207| 680k| for (j = 0; j < eattr_no; j++) {
------------------
| Branch (1207:21): [True: 400k, False: 280k]
------------------
1208| 400k| igraph_attribute_type_t type = (igraph_attribute_type_t) VECTOR(etypes)[j];
------------------
| | 60| 400k|#define VECTOR(v) ((v).stor_begin)
------------------
1209| 400k| const char *name;
1210| 400k| char *newname;
1211| 400k| name = igraph_strvector_get(&enames, j);
1212| 400k| IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
------------------
| | 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]
| | ------------------
------------------
1213| 400k| IGRAPH_FINALLY(igraph_free, newname);
------------------
| | 603| 400k| do { \
| | 604| 400k| /* the following branch makes the compiler check the compatibility of \
| | 605| 400k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 400k| * incorrect destructor function with the pointer */ \
| | 607| 400k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 400k]
| | ------------------
| | 608| 400k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 400k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 400k]
| | ------------------
------------------
1214| 400k| if (!strcmp(newname, "source") || !strcmp(newname, "target")) {
------------------
| Branch (1214:17): [True: 583, False: 399k]
| Branch (1214:47): [True: 323, False: 399k]
------------------
1215| 906| WARN_ONCE(j, 0,
------------------
| | 1113| 906| do { \
| | 1114| 906| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 906|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 906| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 906|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 23, False: 883]
| | ------------------
| | 1116| 46| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 23]
| | ------------------
| | 1117| 23| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 23|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 23| } \
| | 1119| 906| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 906]
| | ------------------
------------------
1216| 906| IGRAPH_WARNINGF("The edge attribute '%s' was ignored while writing GML format.", name));
1217| 399k| } else {
1218| 399k| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (1218:21): [True: 85.2k, False: 314k]
------------------
1219| 85.2k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, name,
------------------
| | 656| 85.2k| do { \
| | 657| 85.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 85.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 85.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.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| 85.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 85.2k]
| | ------------------
------------------
1220| 85.2k| igraph_ess_1(i), &numv));
1221| | /* Treat NaN as missing, skip writing it. GML does not officially support NaN. */
1222| 85.2k| if (! isnan(VECTOR(numv)[0])) {
------------------
| Branch (1222:25): [True: 1.22k, False: 84.0k]
------------------
1223| 1.22k| if (! isfinite(VECTOR(numv)[0])) {
------------------
| Branch (1223:29): [True: 0, False: 1.22k]
------------------
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.22k| CHECK(fprintf(outstream, " %s ", newname));
------------------
| | 848| 1.22k|#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.22k]
| | | Branch (848:116): [Folded, False: 1.22k]
| | ------------------
------------------
1229| 1.22k| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
------------------
| | 848| 1.22k|#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.22k]
| | | Branch (848:116): [Folded, False: 1.22k]
| | ------------------
------------------
1230| 1.22k| CHECK(fputc('\n', outstream));
------------------
| | 848| 1.22k|#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.22k]
| | | Branch (848:116): [Folded, False: 1.22k]
| | ------------------
------------------
1231| 1.22k| }
1232| 314k| } else if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (1232:28): [True: 308k, False: 5.76k]
------------------
1233| 308k| const char *s;
1234| 308k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, name,
------------------
| | 656| 308k| do { \
| | 657| 308k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 308k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 308k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 308k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 308k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 308k]
| | ------------------
------------------
1235| 308k| igraph_ess_1(i), &strv));
1236| 308k| s = igraph_strvector_get(&strv, 0);
1237| 308k| if (needs_coding(s)) {
------------------
| Branch (1237:25): [True: 2.48k, False: 305k]
------------------
1238| 2.48k| char *d;
1239| 2.48k| IGRAPH_CHECK(entity_encode(s, &d, IGRAPH_WRITE_GML_ENCODE_ONLY_QUOT_SW & options));
------------------
| | 656| 2.48k| do { \
| | 657| 2.48k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.48k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.48k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.48k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.48k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.48k]
| | ------------------
------------------
1240| 2.48k| IGRAPH_FINALLY(igraph_free, d);
------------------
| | 603| 2.48k| do { \
| | 604| 2.48k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.48k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.48k| * incorrect destructor function with the pointer */ \
| | 607| 2.48k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.48k]
| | ------------------
| | 608| 2.48k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.48k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.48k]
| | ------------------
------------------
1241| 2.48k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, d));
------------------
| | 848| 2.48k|#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.48k]
| | | Branch (848:116): [Folded, False: 2.48k]
| | ------------------
------------------
1242| 2.48k| IGRAPH_FREE(d);
------------------
| | 36| 2.48k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1243| 2.48k| IGRAPH_FINALLY_CLEAN(1);
1244| 305k| } else {
1245| 305k| CHECK(fprintf(outstream, " %s \"%s\"\n", newname, s));
------------------
| | 848| 305k|#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: 305k]
| | | Branch (848:116): [Folded, False: 305k]
| | ------------------
------------------
1246| 305k| }
1247| 308k| } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (1247:28): [True: 5.76k, False: 0]
------------------
1248| 5.76k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph, name,
------------------
| | 656| 5.76k| do { \
| | 657| 5.76k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.76k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.76k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.76k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.76k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.76k]
| | ------------------
------------------
1249| 5.76k| igraph_ess_1(i), &boolv));
1250| 5.76k| CHECK(fprintf(outstream, " %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
------------------
| | 848| 11.5k|#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.76k]
| | | Branch (848:42): [True: 0, False: 5.76k]
| | | Branch (848:116): [Folded, False: 5.76k]
| | ------------------
------------------
1251| 5.76k| WARN_ONCE(j, 1,
------------------
| | 1113| 5.76k| do { \
| | 1114| 5.76k| igraph_int_t *p = &VECTOR(warning_shown)[attrno]; \
| | ------------------
| | | | 60| 5.76k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
| | 1115| 5.76k| if (! GETBIT(*p, bit)) { \
| | ------------------
| | | | 1110| 5.76k|#define GETBIT(k, i) ((k) & (1 << i))
| | ------------------
| | | Branch (1115:13): [True: 529, False: 5.23k]
| | ------------------
| | 1116| 1.05k| warn; \
| | ------------------
| | | Branch (1116:13): [Folded, False: 529]
| | ------------------
| | 1117| 529| SETBIT(*p, bit); \
| | ------------------
| | | | 1111| 529|#define SETBIT(k, i) ((k) |= (1 << i))
| | ------------------
| | 1118| 529| } \
| | 1119| 5.76k| } while (0)
| | ------------------
| | | Branch (1119:14): [Folded, False: 5.76k]
| | ------------------
------------------
1252| 5.76k| IGRAPH_WARNINGF("The boolean edge attribute '%s' was converted to numeric.", name));
1253| 5.76k| } 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| 399k| }
1258| 400k| IGRAPH_FREE(newname);
------------------
| | 36| 400k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1259| 400k| IGRAPH_FINALLY_CLEAN(1);
1260| 400k| }
1261| 280k| CHECK(fprintf(outstream, " ]\n"));
------------------
| | 848| 280k|#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: 280k]
| | | Branch (848:116): [Folded, False: 280k]
| | ------------------
------------------
1262| 280k| }
1263| |
1264| 3.57k| CHECK(fprintf(outstream, "]\n"));
------------------
| | 848| 3.57k|#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.57k]
| | | Branch (848:116): [Folded, False: 3.57k]
| | ------------------
------------------
1265| |
1266| 3.57k|#undef GETBIT
1267| 3.57k|#undef SETBIT
1268| 3.57k|#undef WARN_ONCE
1269| |
1270| 3.57k| if (&v_myid == myid) {
------------------
| Branch (1270:9): [True: 11, False: 3.56k]
------------------
1271| 11| igraph_vector_destroy(&v_myid);
1272| 11| IGRAPH_FINALLY_CLEAN(1);
1273| 11| }
1274| |
1275| 3.57k| igraph_vector_int_destroy(&warning_shown);
1276| 3.57k| igraph_vector_bool_destroy(&boolv);
1277| 3.57k| igraph_strvector_destroy(&strv);
1278| 3.57k| igraph_vector_destroy(&numv);
1279| 3.57k| igraph_vector_int_destroy(&etypes);
1280| 3.57k| igraph_vector_int_destroy(&vtypes);
1281| 3.57k| igraph_vector_int_destroy(>ypes);
1282| 3.57k| igraph_strvector_destroy(&enames);
1283| 3.57k| igraph_strvector_destroy(&vnames);
1284| 3.57k| igraph_strvector_destroy(&gnames);
1285| 3.57k| IGRAPH_FINALLY_CLEAN(10);
1286| |
1287| 3.57k| return IGRAPH_SUCCESS;
1288| 3.57k|}
gml.c:create_or_update_attribute:
274| 367k| igraph_attribute_record_list_t *attrs) {
275| |
276| 367k| igraph_int_t trieid, triesize = igraph_trie_size(attrnames);
277| 367k| igraph_attribute_type_t desired_type;
278| |
279| 367k| IGRAPH_CHECK(igraph_trie_get(attrnames, name, &trieid));
------------------
| | 656| 367k| do { \
| | 657| 367k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 367k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 367k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 367k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 367k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 367k]
| | ------------------
------------------
280| 367k| if (trieid == triesize) {
------------------
| Branch (280:9): [True: 7.18k, False: 360k]
------------------
281| | /* new attribute */
282| 7.18k| igraph_attribute_record_t atrec;
283| |
284| 7.18k| if (type == IGRAPH_I_GML_TREE_INTEGER || type == IGRAPH_I_GML_TREE_REAL) {
------------------
| Branch (284:13): [True: 4.10k, False: 3.08k]
| Branch (284:50): [True: 41, False: 3.04k]
------------------
285| 4.14k| desired_type = IGRAPH_ATTRIBUTE_NUMERIC;
286| 4.14k| } else if (type == IGRAPH_I_GML_TREE_STRING) {
------------------
| Branch (286:20): [True: 3.04k, False: 0]
------------------
287| 3.04k| desired_type = IGRAPH_ATTRIBUTE_STRING;
288| 3.04k| } else {
289| 0| desired_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
290| 0| }
291| |
292| 7.18k| IGRAPH_CHECK(igraph_attribute_record_init(&atrec, name, desired_type));
------------------
| | 656| 7.18k| do { \
| | 657| 7.18k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.18k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.18k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.18k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 7.18k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.18k]
| | ------------------
------------------
293| 7.18k| IGRAPH_FINALLY(igraph_attribute_record_destroy, &atrec);
------------------
| | 603| 7.18k| do { \
| | 604| 7.18k| /* the following branch makes the compiler check the compatibility of \
| | 605| 7.18k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 7.18k| * incorrect destructor function with the pointer */ \
| | 607| 7.18k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 7.18k]
| | ------------------
| | 608| 7.18k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 7.18k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 7.18k]
| | ------------------
------------------
294| 7.18k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(attrs, &atrec));
------------------
| | 656| 7.18k| do { \
| | 657| 7.18k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.18k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.18k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.18k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 7.18k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.18k]
| | ------------------
------------------
295| 7.18k| IGRAPH_FINALLY_CLEAN(1); /* ownership of 'atrec' taken by 'attrs' */
296| 360k| } else {
297| | /* already seen, should we update type? */
298| 360k| igraph_attribute_record_t *atrec = igraph_attribute_record_list_get_ptr(attrs, trieid);
299| 360k| igraph_attribute_type_t existing_type = atrec->type;
300| 360k| if (type == IGRAPH_I_GML_TREE_STRING) {
------------------
| Branch (300:13): [True: 317k, False: 42.9k]
------------------
301| 317k| if (existing_type != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (301:17): [True: 19, False: 317k]
------------------
302| 19| IGRAPH_CHECK(igraph_attribute_record_set_type(atrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 19| do { \
| | 657| 19| igraph_error_t igraph_i_ret = (expr); \
| | 658| 19| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 19| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 19]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 19| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 19]
| | ------------------
------------------
303| 19| }
304| 317k| } else if (existing_type == IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (304:20): [True: 0, False: 42.9k]
------------------
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| 360k| }
310| |
311| 367k| return IGRAPH_SUCCESS;
312| 367k|}
gml.c:strid:
262| 627k|static const char *strid(igraph_int_t id, const char *prefix) {
263| 627k| static char name[100];
264| | snprintf(name, sizeof(name) / sizeof(char) - 1, "%s%" IGRAPH_PRId, prefix, id);
------------------
| | 63| 627k|# define IGRAPH_PRId PRId64
------------------
265| 627k| return name;
266| 627k|}
gml.c:allocate_attributes:
322| 10.7k|) {
323| 10.7k| igraph_int_t i, n = igraph_attribute_record_list_size(attrs);
324| 17.9k| for (i = 0; i < n; i++) {
------------------
| Branch (324:17): [True: 7.18k, False: 10.7k]
------------------
325| 7.18k| 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| 7.18k| if (atrec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (332:13): [True: 7.18k, False: 0]
------------------
333| 7.18k| IGRAPH_CHECK(igraph_attribute_record_resize(atrec, no_of_items));
------------------
| | 656| 7.18k| do { \
| | 657| 7.18k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.18k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.18k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.18k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 7.18k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.18k]
| | ------------------
------------------
334| 7.18k| } 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| 7.18k| }
338| 10.7k| return IGRAPH_SUCCESS;
339| 10.7k|}
gml.c:igraph_i_gml_toreal:
164| 46.3k|static igraph_real_t igraph_i_gml_toreal(igraph_gml_tree_t *node, igraph_int_t pos) {
165| 46.3k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, pos);
166| |
167| 46.3k| switch (type) {
168| 45.9k| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (168:5): [True: 45.9k, False: 456]
------------------
169| 45.9k| return igraph_gml_tree_get_integer(node, pos);
170| 456| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (170:5): [True: 456, False: 45.9k]
------------------
171| 456| return igraph_gml_tree_get_real(node, pos);
172| 0| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (172:5): [True: 0, False: 46.3k]
------------------
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: 46.3k]
------------------
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| 46.3k| igraph_gml_tree_line(node, pos)); /* LCOV_EXCL_LINE */
178| 46.3k| }
179| 46.3k|}
gml.c:igraph_i_gml_tostring:
181| 320k|static const char *igraph_i_gml_tostring(igraph_gml_tree_t *node, igraph_int_t pos) {
182| 320k| igraph_i_gml_tree_type_t type = igraph_gml_tree_type(node, pos);
183| 320k| static char tmp[100];
184| 320k| const char *p = tmp;
185| 320k| igraph_int_t i;
186| 320k| igraph_real_t d;
187| |
188| 320k| switch (type) {
189| 198| case IGRAPH_I_GML_TREE_INTEGER:
------------------
| Branch (189:5): [True: 198, False: 320k]
------------------
190| 198| i = igraph_gml_tree_get_integer(node, pos);
191| 198| snprintf(tmp, sizeof(tmp) / sizeof(char), "%" IGRAPH_PRId, i);
------------------
| | 63| 198|# define IGRAPH_PRId PRId64
------------------
192| 198| break;
193| 498| case IGRAPH_I_GML_TREE_REAL:
------------------
| Branch (193:5): [True: 498, False: 320k]
------------------
194| 498| d = igraph_gml_tree_get_real(node, pos);
195| 498| igraph_real_snprintf_precise(tmp, sizeof(tmp) / sizeof(char), d);
196| 498| break;
197| 320k| case IGRAPH_I_GML_TREE_STRING:
------------------
| Branch (197:5): [True: 320k, False: 696]
------------------
198| 320k| p = igraph_gml_tree_get_string(node, pos);
199| 320k| break;
200| 0| case IGRAPH_I_GML_TREE_TREE:
------------------
| Branch (200:5): [True: 0, False: 320k]
------------------
201| 0| tmp[0] = '\0'; /* default value of "" when composite is ignored */
202| 0| break;
203| 0| default:
------------------
| Branch (203:5): [True: 0, False: 320k]
------------------
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| 320k| igraph_gml_tree_line(node, pos)); /* LCOV_EXCL_LINE */
207| 320k| }
208| |
209| 320k| return p;
210| 320k|}
gml.c:needs_coding:
54| 644k|static igraph_bool_t needs_coding(const char *str) {
55| 29.9M| while (*str) {
------------------
| Branch (55:12): [True: 29.3M, False: 628k]
------------------
56| 29.3M| if (*str == '&' || *str == '"') {
------------------
| Branch (56:13): [True: 8.41k, False: 29.3M]
| Branch (56:28): [True: 7.14k, False: 29.3M]
------------------
57| 15.5k| return true;
58| 15.5k| }
59| 29.3M| str++;
60| 29.3M| }
61| 628k| return false;
62| 644k|}
gml.c:entity_decode:
110| 7.78k|static igraph_error_t entity_decode(const char *src, char **dest, igraph_bool_t *warned) {
111| 7.78k| const char *entity_names[] = {
112| 7.78k| """, "&", "'", "<", ">"
113| 7.78k| };
114| |
115| 7.78k| const char entity_values[] = {
116| 7.78k| '"', '&', '\'', '<', '>'
117| 7.78k| };
118| |
119| 7.78k| const int entity_count = sizeof entity_values / sizeof entity_values[0];
120| |
121| 7.78k| const char *s;
122| 7.78k| char *d;
123| 7.78k| size_t len = strlen(src);
124| 7.78k| *dest = IGRAPH_CALLOC(len+1, char); /* at most as much storage needed as for 'src' */
------------------
| | 33| 7.78k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 15.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 7.78k, False: 0]
| | | | | Branch (31:24): [True: 7.78k, False: 0]
| | | | | Branch (31:66): [True: 7.78k, False: 0]
| | | | ------------------
| | ------------------
------------------
125| 7.78k| IGRAPH_CHECK_OOM(dest, "Not enough memory to decode string during GML import.");
------------------
| | 709| 7.78k| do { \
| | 710| 7.78k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 7.78k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.78k]
| | | | ------------------
| | ------------------
| | 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.78k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 7.78k]
| | ------------------
------------------
126| |
127| 81.0M| for (s = src, d = *dest; *s != '\0';) {
------------------
| Branch (127:30): [True: 81.0M, False: 7.78k]
------------------
128| 81.0M| if (*s == '&') {
------------------
| Branch (128:13): [True: 15.5M, False: 65.5M]
------------------
129| 15.5M| int i;
130| 15.5M| for (i=0; i < entity_count; i++) {
------------------
| Branch (130:23): [True: 15.5M, False: 0]
------------------
131| 15.5M| size_t entity_len = strlen(entity_names[i]);
132| 15.5M| if (!strncasecmp(s, entity_names[i], entity_len)) {
------------------
| Branch (132:21): [True: 15.5M, False: 1.48k]
------------------
133| 15.5M| *d++ = entity_values[i];
134| 15.5M| s += entity_len;
135| 15.5M| break;
136| 15.5M| }
137| 15.5M| }
138| | /* None of the known entities match, report warning and pass through unchanged. */
139| 15.5M| if (i == entity_count) {
------------------
| Branch (139:17): [True: 0, False: 15.5M]
------------------
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.5M| } else {
156| 65.5M| *d++ = *s++;
157| 65.5M| }
158| 81.0M| }
159| 7.78k| *d = '\0';
160| |
161| 7.78k| return IGRAPH_SUCCESS;
162| 7.78k|}
gml.c:prune_unknown_attributes:
236| 10.7k|static igraph_error_t prune_unknown_attributes(igraph_attribute_record_list_t *attrs) {
237| 10.7k| igraph_int_t i, n;
238| 10.7k| igraph_vector_int_t to_remove;
239| |
240| 10.7k| IGRAPH_VECTOR_INT_INIT_FINALLY(&to_remove, 0);
------------------
| | 119| 10.7k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 10.7k| do { \
| | | | 657| 10.7k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 10.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 10.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 10.7k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 10.7k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 10.7k]
| | | | ------------------
| | ------------------
| | 120| 10.7k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 10.7k| do { \
| | | | 604| 10.7k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 10.7k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 10.7k| * incorrect destructor function with the pointer */ \
| | | | 607| 10.7k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 10.7k]
| | | | ------------------
| | | | 608| 10.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 10.7k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 10.7k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 10.7k]
| | ------------------
------------------
241| |
242| 10.7k| n = igraph_attribute_record_list_size(attrs);
243| 17.9k| for (i = 0; i < n; i++) {
------------------
| Branch (243:17): [True: 7.18k, False: 10.7k]
------------------
244| 7.18k| igraph_attribute_record_t *atrec = igraph_attribute_record_list_get_ptr(attrs, i);
245| 7.18k| if (atrec->type == IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (245:13): [True: 0, False: 7.18k]
------------------
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| 7.18k| }
249| |
250| 10.7k| n = igraph_vector_int_size(&to_remove);
251| 10.7k| for (i = n - 1; i >= 0; i--) {
------------------
| Branch (251:21): [True: 0, False: 10.7k]
------------------
252| 0| igraph_attribute_record_list_discard(attrs, VECTOR(to_remove)[i]);
------------------
| | 60| 0|#define VECTOR(v) ((v).stor_begin)
------------------
253| 0| }
254| |
255| 10.7k| igraph_vector_int_destroy(&to_remove);
256| 10.7k| IGRAPH_FINALLY_CLEAN(1);
257| |
258| 10.7k| return IGRAPH_SUCCESS;
259| 10.7k|}
gml.c:entity_encode:
67| 7.78k|static igraph_error_t entity_encode(const char *src, char **dest, igraph_bool_t only_quot) {
68| 7.78k| igraph_int_t destlen = 0;
69| 7.78k| const char *s;
70| 7.78k| char *d;
71| |
72| 81.0M| for (s = src; *s != '\0'; s++, destlen++) {
------------------
| Branch (72:19): [True: 81.0M, False: 7.78k]
------------------
73| 81.0M| switch (*s) {
------------------
| Branch (73:17): [True: 15.5M, False: 65.5M]
------------------
74| 1.48k| case '&': /* & */
------------------
| Branch (74:9): [True: 1.48k, False: 81.0M]
------------------
75| 1.48k| if (! only_quot) {
------------------
| Branch (75:17): [True: 1.48k, False: 0]
------------------
76| 1.48k| destlen += 4;
77| 1.48k| }
78| 1.48k| break;
79| 15.5M| case '"': /* " */
------------------
| Branch (79:9): [True: 15.5M, False: 65.5M]
------------------
80| 15.5M| destlen += 5; break;
81| 81.0M| }
82| 81.0M| }
83| 7.78k| *dest = IGRAPH_CALLOC(destlen + 1, char);
------------------
| | 33| 7.78k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 15.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 7.78k, False: 0]
| | | | | Branch (31:24): [True: 7.78k, False: 0]
| | | | | Branch (31:66): [True: 7.78k, False: 0]
| | | | ------------------
| | ------------------
------------------
84| 7.78k| IGRAPH_CHECK_OOM(dest, "Not enough memory to encode string for GML export.");
------------------
| | 709| 7.78k| do { \
| | 710| 7.78k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 7.78k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.78k]
| | | | ------------------
| | ------------------
| | 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.78k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 7.78k]
| | ------------------
------------------
85| 81.0M| for (s = src, d = *dest; *s != '\0'; s++, d++) {
------------------
| Branch (85:30): [True: 81.0M, False: 7.78k]
------------------
86| 81.0M| switch (*s) {
87| 1.48k| case '&':
------------------
| Branch (87:9): [True: 1.48k, False: 81.0M]
------------------
88| 1.48k| if (! only_quot) {
------------------
| Branch (88:17): [True: 1.48k, False: 0]
------------------
89| 1.48k| strcpy(d, "&");
90| 1.48k| d += 4;
91| 1.48k| } else {
92| 0| *d = *s;
93| 0| }
94| 1.48k| break;
95| 15.5M| case '"':
------------------
| Branch (95:9): [True: 15.5M, False: 65.5M]
------------------
96| 15.5M| strcpy(d, """); d += 5; break;
97| 65.5M| default:
------------------
| Branch (97:9): [True: 65.5M, False: 15.5M]
------------------
98| 65.5M| *d = *s;
99| 81.0M| }
100| 81.0M| }
101| 7.78k| *d = '\0';
102| 7.78k| return IGRAPH_SUCCESS;
103| 7.78k|}
gml.c:igraph_i_vector_is_duplicate_free:
821| 44|static igraph_error_t igraph_i_vector_is_duplicate_free(const igraph_vector_t *v, igraph_bool_t *res) {
822| 44| igraph_vector_t u;
823| 44| igraph_int_t n = igraph_vector_size(v);
824| |
825| 44| if (n < 2) {
------------------
| Branch (825:9): [True: 11, False: 33]
------------------
826| 11| *res = true;
827| 11| return IGRAPH_SUCCESS;
828| 11| }
829| |
830| 33| IGRAPH_CHECK(igraph_vector_init_copy(&u, v));
------------------
| | 656| 33| do { \
| | 657| 33| igraph_error_t igraph_i_ret = (expr); \
| | 658| 33| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 33| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 33]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 33| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 33]
| | ------------------
------------------
831| 33| IGRAPH_FINALLY(igraph_vector_destroy, &u);
------------------
| | 603| 33| do { \
| | 604| 33| /* the following branch makes the compiler check the compatibility of \
| | 605| 33| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 33| * incorrect destructor function with the pointer */ \
| | 607| 33| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 33]
| | ------------------
| | 608| 33| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 33| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 33]
| | ------------------
------------------
832| 33| igraph_vector_sort(&u);
833| |
834| 33| *res = true;
835| 33| for (igraph_int_t i=1; i < n; i++) {
------------------
| Branch (835:28): [True: 33, False: 0]
------------------
836| 33| if (VECTOR(u)[i-1] == VECTOR(u)[i]) {
------------------
| | 60| 33|#define VECTOR(v) ((v).stor_begin)
------------------
if (VECTOR(u)[i-1] == VECTOR(u)[i]) {
------------------
| | 60| 33|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (836:13): [True: 33, False: 0]
------------------
837| 33| *res = false;
838| 33| break;
839| 33| }
840| 33| }
841| |
842| 33| igraph_vector_destroy(&u);
843| 33| IGRAPH_FINALLY_CLEAN(1);
844| |
845| 33| return IGRAPH_SUCCESS;
846| 33|}
gml.c:igraph_i_gml_convert_to_key:
792| 420k|static igraph_error_t igraph_i_gml_convert_to_key(const char *orig, char **key) {
793| 420k| char strno[50];
794| 420k| size_t i, len = strlen(orig), newlen = 0, plen = 0;
795| |
796| | /* do we need a prefix? */
797| 420k| if (len == 0 || !isalpha(orig[0])) {
------------------
| Branch (797:9): [True: 223, False: 419k]
| Branch (797:21): [True: 9.66k, False: 410k]
------------------
798| 9.89k| snprintf(strno, sizeof(strno) - 1, "igraph");
799| 9.89k| plen = newlen = strlen(strno);
800| 9.89k| }
801| 166M| for (i = 0; i < len; i++) {
------------------
| Branch (801:17): [True: 166M, False: 420k]
------------------
802| 166M| if (isalnum(orig[i])) {
------------------
| Branch (802:13): [True: 19.4M, False: 146M]
------------------
803| 19.4M| newlen++;
804| 19.4M| }
805| 166M| }
806| 420k| *key = IGRAPH_CALLOC(newlen + 1, char);
------------------
| | 33| 420k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 840k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 420k, False: 0]
| | | | | Branch (31:24): [True: 420k, False: 0]
| | | | | Branch (31:66): [True: 420k, False: 0]
| | | | ------------------
| | ------------------
------------------
807| 420k| IGRAPH_CHECK_OOM(*key, "Writing GML format failed.");
------------------
| | 709| 420k| do { \
| | 710| 420k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 420k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 420k]
| | | | ------------------
| | ------------------
| | 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| 420k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 420k]
| | ------------------
------------------
808| 420k| memcpy(*key, strno, plen * sizeof(char));
809| 166M| for (i = 0; i < len; i++) {
------------------
| Branch (809:17): [True: 166M, False: 420k]
------------------
810| 166M| if (isalnum(orig[i])) {
------------------
| Branch (810:13): [True: 19.4M, False: 146M]
------------------
811| 19.4M| (*key)[plen++] = orig[i];
812| 19.4M| }
813| 166M| }
814| 420k| (*key)[newlen] = '\0';
815| |
816| 420k| return IGRAPH_SUCCESS;
817| 420k|}
igraph_read_graph_graphml:
1471| 24.9k|igraph_error_t igraph_read_graph_graphml(igraph_t *graph, FILE *instream, igraph_int_t index) {
1472| |
1473| 24.9k|#if HAVE_LIBXML == 1
1474| 24.9k| xmlParserCtxtPtr ctxt;
1475| 24.9k| xmlGenericErrorFunc libxml_old_generic_error_handler;
1476| 24.9k| void* libxml_old_generic_error_context;
1477| 24.9k| xmlStructuredErrorFunc libxml_old_structured_error_handler;
1478| 24.9k| void* libxml_old_structured_error_context;
1479| 24.9k| xmlDocPtr doc;
1480| |
1481| 24.9k| struct igraph_i_graphml_parser_state state;
1482| 24.9k| int res;
1483| 24.9k| char buffer[4096];
1484| 24.9k| igraph_bool_t parsing_successful;
1485| 24.9k| char* error_message;
1486| |
1487| 24.9k| if (index < 0) {
------------------
| Branch (1487:9): [True: 0, False: 24.9k]
------------------
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| 24.9k| xmlInitParser();
1492| |
1493| 24.9k| IGRAPH_CHECK(igraph_i_graphml_parser_state_init(&state, graph, index));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
1494| 24.9k| IGRAPH_FINALLY(igraph_i_graphml_parser_state_destroy, &state);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
1495| |
1496| | /* Create a progressive parser context and use the first 4K to detect the
1497| | * encoding */
1498| 24.9k| res = (int) fread(buffer, 1, sizeof(buffer), instream);
1499| 24.9k| if (res < (int) sizeof buffer && !feof(instream)) {
------------------
| Branch (1499:9): [True: 21.3k, False: 3.52k]
| Branch (1499:38): [True: 0, False: 21.3k]
------------------
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| 24.9k| libxml_old_generic_error_handler = xmlGenericError;
------------------
| | 976| 24.9k| #define xmlGenericError (*__xmlGenericError())
------------------
1506| 24.9k| libxml_old_generic_error_context = xmlGenericErrorContext;
------------------
| | 983| 24.9k| #define xmlGenericErrorContext (*__xmlGenericErrorContext())
------------------
1507| 24.9k| libxml_old_structured_error_handler = xmlStructuredError;
------------------
| | 990| 24.9k| #define xmlStructuredError (*__xmlStructuredError())
------------------
1508| 24.9k| libxml_old_structured_error_context = xmlStructuredErrorContext;
------------------
| | 997| 24.9k| #define xmlStructuredErrorContext (*__xmlStructuredErrorContext())
------------------
1509| 24.9k| xmlSetGenericErrorFunc(&state, &igraph_i_libxml_generic_error_handler);
1510| 24.9k| 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| 24.9k| IGRAPH_FINALLY_ENTER();
1518| 24.9k| {
1519| 24.9k| ctxt = xmlCreatePushParserCtxt(&igraph_i_graphml_sax_handler,
1520| 24.9k| &state,
1521| 24.9k| buffer,
1522| 24.9k| res,
1523| 24.9k| NULL);
1524| 24.9k| if (ctxt) {
------------------
| Branch (1524:13): [True: 24.9k, False: 0]
------------------
1525| 24.9k| if (xmlCtxtUseOptions(ctxt,
------------------
| Branch (1525:17): [True: 0, False: 24.9k]
------------------
1526| 24.9k| XML_PARSE_NOBLANKS |
1527| 24.9k| XML_PARSE_NONET | XML_PARSE_NSCLEAN |
1528| 24.9k| XML_PARSE_NOCDATA | XML_PARSE_HUGE
1529| 24.9k| )) {
1530| 0| xmlFreeParserCtxt(ctxt);
1531| 0| ctxt = NULL;
1532| 0| }
1533| 24.9k| }
1534| |
1535| | /* Do the parsing */
1536| 24.9k| if (ctxt) {
------------------
| Branch (1536:13): [True: 24.9k, False: 0]
------------------
1537| 424k| while ((res = (int) fread(buffer, 1, sizeof buffer, instream)) > 0) {
------------------
| Branch (1537:20): [True: 400k, False: 24.4k]
------------------
1538| 400k| xmlParseChunk(ctxt, buffer, res, 0);
1539| 400k| if (!state.successful) {
------------------
| Branch (1539:21): [True: 470, False: 399k]
------------------
1540| 470| break;
1541| 470| }
1542| 399k| IGRAPH_ALLOW_INTERRUPTION();
------------------
| | 46| 399k| do { \
| | 47| 399k| if (igraph_i_interruption_handler) { \
| | ------------------
| | | Branch (47:13): [True: 0, False: 399k]
| | ------------------
| | 48| 0| if (igraph_allow_interruption()) { \
| | ------------------
| | | Branch (48:17): [True: 0, False: 0]
| | ------------------
| | 49| 0| return IGRAPH_INTERRUPTED; \
| | 50| 0| } \
| | 51| 0| } \
| | 52| 399k| } while (0)
| | ------------------
| | | Branch (52:14): [Folded, False: 399k]
| | ------------------
------------------
1543| 399k| }
1544| 24.9k| xmlParseChunk(ctxt, buffer, res, 1);
1545| 24.9k| }
1546| 24.9k| }
1547| 24.9k| IGRAPH_FINALLY_EXIT();
1548| |
1549| | /* Restore error handlers */
1550| 24.9k| xmlSetGenericErrorFunc(libxml_old_generic_error_context, libxml_old_generic_error_handler);
1551| 24.9k| xmlSetStructuredErrorFunc(libxml_old_structured_error_context, libxml_old_structured_error_handler);
1552| |
1553| | /* Free the context */
1554| 24.9k| if (ctxt) {
------------------
| Branch (1554:9): [True: 24.9k, False: 0]
------------------
1555| 24.9k| doc = ctxt->myDoc;
1556| 24.9k| xmlFreeParserCtxt(ctxt);
1557| 24.9k| if (doc) {
------------------
| Branch (1557:13): [True: 1.49k, False: 23.4k]
------------------
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.49k| xmlFreeDoc(doc);
1561| 1.49k| }
1562| 24.9k| } 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| 24.9k| parsing_successful = state.successful;
1571| 24.9k| error_message = parsing_successful || state.error_message == NULL ? NULL : strdup(state.error_message);
------------------
| Branch (1571:21): [True: 7.16k, False: 17.7k]
| Branch (1571:43): [True: 0, False: 17.7k]
------------------
1572| |
1573| | /* ...and we can also put the error message pointer on the FINALLY stack */
1574| 24.9k| if (error_message != NULL) {
------------------
| Branch (1574:9): [True: 17.7k, False: 7.16k]
------------------
1575| 17.7k| IGRAPH_FINALLY(igraph_free, error_message);
------------------
| | 603| 17.7k| do { \
| | 604| 17.7k| /* the following branch makes the compiler check the compatibility of \
| | 605| 17.7k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 17.7k| * incorrect destructor function with the pointer */ \
| | 607| 17.7k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 17.7k]
| | ------------------
| | 608| 17.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 17.7k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 17.7k]
| | ------------------
------------------
1576| 17.7k| }
1577| |
1578| | /* Trigger the stored error if needed */
1579| 24.9k| if (!parsing_successful) {
------------------
| Branch (1579:9): [True: 17.7k, False: 7.16k]
------------------
1580| 17.7k| if (error_message != NULL) {
------------------
| Branch (1580:13): [True: 17.7k, False: 0]
------------------
1581| 17.7k| size_t len = strlen(error_message);
1582| 17.7k| if (error_message[len-1] == '\n') {
------------------
| Branch (1582:17): [True: 17.3k, False: 406]
------------------
1583| 17.3k| error_message[len-1] = '\0';
1584| 17.3k| }
1585| 17.7k| IGRAPH_ERROR(error_message, IGRAPH_PARSEERROR);
------------------
| | 426| 17.7k| do { \
| | 427| 17.7k| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 17.7k| return igraph_errno ; \
| | 429| 17.7k| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1586| 17.7k| } 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| 17.7k| }
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| 7.16k| if (state.index >= 0) {
------------------
| Branch (1593:9): [True: 48, False: 7.11k]
------------------
1594| 48| IGRAPH_ERROR("Graph index was too large.", IGRAPH_EINVAL);
------------------
| | 426| 48| do { \
| | 427| 48| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 48| return igraph_errno ; \
| | 429| 48| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1595| 48| }
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| 7.11k| IGRAPH_CHECK(igraph_i_graphml_parser_state_finish_parsing(&state));
------------------
| | 656| 7.11k| do { \
| | 657| 7.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.11k]
| | ------------------
------------------
1600| |
1601| 7.11k| igraph_i_graphml_parser_state_destroy(&state);
1602| 7.11k| IGRAPH_FINALLY_CLEAN(1);
1603| |
1604| 7.11k| 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| 7.11k|}
igraph_write_graph_graphml:
1649| 3.57k| igraph_bool_t prefixattr) {
1650| 3.57k| int ret;
1651| 3.57k| igraph_int_t l, vc;
1652| 3.57k| igraph_eit_t it;
1653| 3.57k| igraph_strvector_t gnames, vnames, enames;
1654| 3.57k| igraph_vector_int_t gtypes, vtypes, etypes;
1655| 3.57k| igraph_int_t i;
1656| 3.57k| igraph_vector_t numv;
1657| 3.57k| igraph_strvector_t strv;
1658| 3.57k| igraph_vector_bool_t boolv;
1659| 3.57k| const char *gprefix = prefixattr ? "g_" : "";
------------------
| Branch (1659:27): [True: 0, False: 3.57k]
------------------
1660| 3.57k| const char *vprefix = prefixattr ? "v_" : "";
------------------
| Branch (1660:27): [True: 0, False: 3.57k]
------------------
1661| 3.57k| const char *eprefix = prefixattr ? "e_" : "";
------------------
| Branch (1661:27): [True: 0, False: 3.57k]
------------------
1662| 3.57k| char what[100];
1663| |
1664| 3.57k| ret = fprintf(outstream, "\n");
1665| 3.57k| if (ret < 0) {
------------------
| Branch (1665:9): [True: 0, False: 3.57k]
------------------
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.57k| ret = fprintf(outstream, "\n", GRAPHML_NAMESPACE_URI);
------------------
| | 38| 3.57k|#define GRAPHML_NAMESPACE_URI "http://graphml.graphdrawing.org/xmlns"
------------------
1681| 3.57k| if (ret < 0) {
------------------
| Branch (1681:9): [True: 0, False: 3.57k]
------------------
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.57k| ret = fprintf(outstream, "\n");
1685| 3.57k| if (ret < 0) {
------------------
| Branch (1685:9): [True: 0, False: 3.57k]
------------------
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.57k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.57k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 105| 3.57k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.57k]
| | ------------------
------------------
1692| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
1693| 3.57k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);
------------------
| | 109| 3.57k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 110| 3.57k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 3.57k]
| | ------------------
------------------
1694| |
1695| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
1696| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
1697| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
1698| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(>ypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
1699| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vtypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
1700| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&etypes, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
1701| 3.57k| IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
1702| 3.57k| &gnames, >ypes,
1703| 3.57k| &vnames, &vtypes,
1704| 3.57k| &enames, &etypes));
1705| |
1706| | /* graph attributes */
1707| 4.44k| for (i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (1707:17): [True: 865, False: 3.57k]
------------------
1708| 865| const char *name; char *name_escaped;
1709| 865| name = igraph_strvector_get(&gnames, i);
1710| 865| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 865| do { \
| | 657| 865| igraph_error_t igraph_i_ret = (expr); \
| | 658| 865| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 865| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 865]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 865| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 865]
| | ------------------
------------------
1711| 865| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 603| 865| do { \
| | 604| 865| /* the following branch makes the compiler check the compatibility of \
| | 605| 865| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 865| * incorrect destructor function with the pointer */ \
| | 607| 865| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 865]
| | ------------------
| | 608| 865| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 865| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 865]
| | ------------------
------------------
1712| 865| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 865|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1712:13): [True: 628, False: 237]
------------------
1713| 628| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1714| 628| if (ret < 0) {
------------------
| Branch (1714:17): [True: 0, False: 628]
------------------
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| 628| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 237|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1717:20): [True: 87, False: 150]
------------------
1718| 87| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1719| 87| if (ret < 0) {
------------------
| Branch (1719:17): [True: 0, False: 87]
------------------
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| 150| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 150|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1722:20): [True: 150, False: 0]
------------------
1723| 150| ret = fprintf(outstream, " \n", gprefix, name_escaped, name_escaped);
1724| 150| if (ret < 0) {
------------------
| Branch (1724:17): [True: 0, False: 150]
------------------
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| 150| }
1728| 865| IGRAPH_FREE(name_escaped);
------------------
| | 36| 865|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1729| 865| IGRAPH_FINALLY_CLEAN(1);
1730| 865| }
1731| |
1732| | /* vertex attributes */
1733| 8.97k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1733:17): [True: 5.40k, False: 3.57k]
------------------
1734| 5.40k| const char *name; char *name_escaped;
1735| 5.40k| name = igraph_strvector_get(&vnames, i);
1736| 5.40k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 5.40k| do { \
| | 657| 5.40k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.40k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.40k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.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| 5.40k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.40k]
| | ------------------
------------------
1737| 5.40k| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 603| 5.40k| do { \
| | 604| 5.40k| /* the following branch makes the compiler check the compatibility of \
| | 605| 5.40k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 5.40k| * incorrect destructor function with the pointer */ \
| | 607| 5.40k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 5.40k]
| | ------------------
| | 608| 5.40k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 5.40k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 5.40k]
| | ------------------
------------------
1738| 5.40k| if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 5.40k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1738:13): [True: 4.52k, False: 877]
------------------
1739| 4.52k| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1740| 4.52k| if (ret < 0) {
------------------
| Branch (1740:17): [True: 0, False: 4.52k]
------------------
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.52k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 877|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1743:20): [True: 291, False: 586]
------------------
1744| 291| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1745| 291| if (ret < 0) {
------------------
| Branch (1745:17): [True: 0, False: 291]
------------------
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| 586| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 586|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1748:20): [True: 586, False: 0]
------------------
1749| 586| ret = fprintf(outstream, " \n", vprefix, name_escaped, name_escaped);
1750| 586| if (ret < 0) {
------------------
| Branch (1750:17): [True: 0, False: 586]
------------------
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| 586| }
1754| 5.40k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 5.40k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1755| 5.40k| IGRAPH_FINALLY_CLEAN(1);
1756| 5.40k| }
1757| |
1758| | /* edge attributes */
1759| 6.39k| for (i = 0; i < igraph_vector_int_size(&etypes); i++) {
------------------
| Branch (1759:17): [True: 2.81k, False: 3.57k]
------------------
1760| 2.81k| const char *name; char *name_escaped;
1761| 2.81k| name = igraph_strvector_get(&enames, i);
1762| 2.81k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 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]
| | ------------------
------------------
1763| 2.81k| IGRAPH_FINALLY(igraph_free, name_escaped);
------------------
| | 603| 2.81k| do { \
| | 604| 2.81k| /* the following branch makes the compiler check the compatibility of \
| | 605| 2.81k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 2.81k| * incorrect destructor function with the pointer */ \
| | 607| 2.81k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 2.81k]
| | ------------------
| | 608| 2.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 2.81k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 2.81k]
| | ------------------
------------------
1764| 2.81k| if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 2.81k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1764:13): [True: 1.76k, False: 1.05k]
------------------
1765| 1.76k| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1766| 1.76k| if (ret < 0) {
------------------
| Branch (1766:17): [True: 0, False: 1.76k]
------------------
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.76k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 1.05k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1769:20): [True: 463, False: 594]
------------------
1770| 463| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1771| 463| if (ret < 0) {
------------------
| Branch (1771:17): [True: 0, False: 463]
------------------
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| 594| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 594|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1774:20): [True: 594, False: 0]
------------------
1775| 594| ret = fprintf(outstream, " \n", eprefix, name_escaped, name_escaped);
1776| 594| if (ret < 0) {
------------------
| Branch (1776:17): [True: 0, False: 594]
------------------
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| 594| }
1780| 2.81k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 2.81k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1781| 2.81k| IGRAPH_FINALLY_CLEAN(1);
1782| 2.81k| }
1783| |
1784| 3.57k| ret = fprintf(outstream, " \n", (igraph_is_directed(graph) ? "directed" : "undirected"));
------------------
| Branch (1784:74): [True: 134, False: 3.44k]
------------------
1785| 3.57k| if (ret < 0) {
------------------
| Branch (1785:9): [True: 0, False: 3.57k]
------------------
1786| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1787| 0| }
1788| |
1789| | /* Write the graph atributes before anything else */
1790| |
1791| 4.44k| for (i = 0; i < igraph_vector_int_size(>ypes); i++) {
------------------
| Branch (1791:17): [True: 865, False: 3.57k]
------------------
1792| 865| const char *name; char *name_escaped;
1793| 865| if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 865|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1793:13): [True: 87, False: 778]
------------------
1794| 87| name = igraph_strvector_get(&gnames, i);
1795| 87| IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
------------------
| | 656| 87| do { \
| | 657| 87| igraph_error_t igraph_i_ret = (expr); \
| | 658| 87| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 87| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 87]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 87| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 87]
| | ------------------
------------------
1796| 87| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1796:17): [True: 18, False: 69]
------------------
1797| 18| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 18| do { \
| | 657| 18| igraph_error_t igraph_i_ret = (expr); \
| | 658| 18| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 18| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 18]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 18| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 18]
| | ------------------
------------------
1798| 18| ret = fprintf(outstream, " ", gprefix, name_escaped);
1799| 18| IGRAPH_FREE(name_escaped);
------------------
| | 36| 18|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1800| 18| if (ret < 0) {
------------------
| Branch (1800:21): [True: 0, False: 18]
------------------
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| 18| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 18|#define VECTOR(v) ((v).stor_begin)
------------------
1804| 18| if (ret < 0) {
------------------
| Branch (1804:21): [True: 0, False: 18]
------------------
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| 18| ret = fprintf(outstream, "\n");
1808| 18| if (ret < 0) {
------------------
| Branch (1808:21): [True: 0, False: 18]
------------------
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| 18| }
1812| 778| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 778|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1812:20): [True: 628, False: 150]
------------------
1813| 628| const char *s;
1814| 628| char *s_escaped;
1815| 628| name = igraph_strvector_get(&gnames, i);
1816| 628| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 628| do { \
| | 657| 628| igraph_error_t igraph_i_ret = (expr); \
| | 658| 628| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 628| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 628]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 628| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 628]
| | ------------------
------------------
1817| 628| ret = fprintf(outstream, " ", gprefix,
1818| 628| name_escaped);
1819| 628| IGRAPH_FREE(name_escaped);
------------------
| | 36| 628|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1820| 628| if (ret < 0) {
------------------
| Branch (1820:17): [True: 0, False: 628]
------------------
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| 628| IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
------------------
| | 656| 628| do { \
| | 657| 628| igraph_error_t igraph_i_ret = (expr); \
| | 658| 628| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 628| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 628]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 628| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 628]
| | ------------------
------------------
1824| 628| s = igraph_strvector_get(&strv, 0);
1825| 628| snprintf(what, sizeof(what) / sizeof(what[0]), "the value of the '%s' graph attribute", name);
1826| 628| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 628| do { \
| | 657| 628| igraph_error_t igraph_i_ret = (expr); \
| | 658| 628| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 628| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 628]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 628| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 628]
| | ------------------
------------------
1827| 628| ret = fprintf(outstream, "%s", s_escaped);
1828| 628| IGRAPH_FREE(s_escaped);
------------------
| | 36| 628|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1829| 628| if (ret < 0) {
------------------
| Branch (1829:17): [True: 0, False: 628]
------------------
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| 628| ret = fprintf(outstream, "\n");
1833| 628| if (ret < 0) {
------------------
| Branch (1833:17): [True: 0, False: 628]
------------------
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| 628| } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 150|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1836:20): [True: 150, False: 0]
------------------
1837| 150| name = igraph_strvector_get(&gnames, i);
1838| 150| IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
------------------
| | 656| 150| do { \
| | 657| 150| igraph_error_t igraph_i_ret = (expr); \
| | 658| 150| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 150| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 150]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 150| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 150]
| | ------------------
------------------
1839| 150| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "graph attribute name"));
------------------
| | 656| 150| do { \
| | 657| 150| igraph_error_t igraph_i_ret = (expr); \
| | 658| 150| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 150| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 150]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 150| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 150]
| | ------------------
------------------
1840| 150| ret = fprintf(outstream, " %s\n",
1841| 150| gprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 150|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1841:50): [True: 1, False: 149]
------------------
1842| 150| IGRAPH_FREE(name_escaped);
------------------
| | 36| 150|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1843| 150| if (ret < 0) {
------------------
| Branch (1843:17): [True: 0, False: 150]
------------------
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| 150| }
1847| 865| }
1848| |
1849| | /* Let's dump the nodes first */
1850| 3.57k| vc = igraph_vcount(graph);
1851| 36.8k| for (l = 0; l < vc; l++) {
------------------
| Branch (1851:17): [True: 33.2k, False: 3.57k]
------------------
1852| 33.2k| const char *name; char *name_escaped;
1853| 33.2k| ret = fprintf(outstream, " \n", l);
1854| |
1855| 33.2k| if (ret < 0) {
------------------
| Branch (1855:13): [True: 0, False: 33.2k]
------------------
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| 85.2k| for (i = 0; i < igraph_vector_int_size(&vtypes); i++) {
------------------
| Branch (1859:21): [True: 51.9k, False: 33.2k]
------------------
1860| 51.9k| if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 51.9k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1860:17): [True: 4.99k, False: 46.9k]
------------------
1861| 4.99k| name = igraph_strvector_get(&vnames, i);
1862| 4.99k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name,
------------------
| | 656| 4.99k| do { \
| | 657| 4.99k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.99k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.99k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.99k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.99k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.99k]
| | ------------------
------------------
1863| 4.99k| igraph_vss_1(l), &numv));
1864| 4.99k| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1864:21): [True: 4.10k, False: 885]
------------------
1865| 4.10k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 4.10k| do { \
| | 657| 4.10k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.10k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.10k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.10k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 4.10k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.10k]
| | ------------------
------------------
1866| 4.10k| ret = fprintf(outstream, " ", vprefix, name_escaped);
1867| 4.10k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 4.10k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1868| 4.10k| if (ret < 0) {
------------------
| Branch (1868:25): [True: 0, False: 4.10k]
------------------
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.10k| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 4.10k|#define VECTOR(v) ((v).stor_begin)
------------------
1872| 4.10k| if (ret < 0) {
------------------
| Branch (1872:25): [True: 0, False: 4.10k]
------------------
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.10k| ret = fprintf(outstream, "\n");
1876| 4.10k| if (ret < 0) {
------------------
| Branch (1876:25): [True: 0, False: 4.10k]
------------------
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.10k| }
1880| 46.9k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 46.9k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1880:24): [True: 42.3k, False: 4.62k]
------------------
1881| 42.3k| const char *s;
1882| 42.3k| char *s_escaped;
1883| 42.3k| name = igraph_strvector_get(&vnames, i);
1884| 42.3k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 42.3k| do { \
| | 657| 42.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.3k]
| | ------------------
------------------
1885| 42.3k| ret = fprintf(outstream, " ", vprefix,
1886| 42.3k| name_escaped);
1887| 42.3k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 42.3k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1888| 42.3k| if (ret < 0) {
------------------
| Branch (1888:21): [True: 0, False: 42.3k]
------------------
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.3k| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name,
------------------
| | 656| 42.3k| do { \
| | 657| 42.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.3k]
| | ------------------
------------------
1892| 42.3k| igraph_vss_1(l), &strv));
1893| 42.3k| s = igraph_strvector_get(&strv, 0);
1894| 42.3k| snprintf(what, sizeof(what) / sizeof(what[0]), "a value of the '%s' vertex attribute", name);
1895| 42.3k| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 42.3k| do { \
| | 657| 42.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 42.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 42.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 42.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| 42.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 42.3k]
| | ------------------
------------------
1896| 42.3k| ret = fprintf(outstream, "%s", s_escaped);
1897| 42.3k| IGRAPH_FREE(s_escaped);
------------------
| | 36| 42.3k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1898| 42.3k| if (ret < 0) {
------------------
| Branch (1898:21): [True: 0, False: 42.3k]
------------------
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.3k| ret = fprintf(outstream, "\n");
1902| 42.3k| if (ret < 0) {
------------------
| Branch (1902:21): [True: 0, False: 42.3k]
------------------
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.3k| } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 4.62k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1905:24): [True: 4.62k, False: 0]
------------------
1906| 4.62k| name = igraph_strvector_get(&vnames, i);
1907| 4.62k| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name,
------------------
| | 656| 4.62k| do { \
| | 657| 4.62k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.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| 4.62k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.62k]
| | ------------------
------------------
1908| 4.62k| igraph_vss_1(l), &boolv));
1909| 4.62k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "vertex attribute name"));
------------------
| | 656| 4.62k| do { \
| | 657| 4.62k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.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| 4.62k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.62k]
| | ------------------
------------------
1910| 4.62k| ret = fprintf(outstream, " %s\n",
1911| 4.62k| vprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 4.62k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1911:54): [True: 20, False: 4.60k]
------------------
1912| 4.62k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 4.62k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1913| 4.62k| if (ret < 0) {
------------------
| Branch (1913:21): [True: 0, False: 4.62k]
------------------
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.62k| }
1917| 51.9k| }
1918| |
1919| 33.2k| ret = fprintf(outstream, " \n");
1920| 33.2k| if (ret < 0) {
------------------
| Branch (1920:13): [True: 0, False: 33.2k]
------------------
1921| 0| IGRAPH_ERROR("Write failed.", IGRAPH_EFILE);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1922| 0| }
1923| 33.2k| }
1924| |
1925| | /* Now the edges */
1926| 3.57k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &it));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
1927| 3.57k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
1928| 284k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 284k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (1928:12): [True: 280k, False: 3.57k]
------------------
1929| 280k| igraph_int_t from, to;
1930| 280k| const char *name; char *name_escaped;
1931| 280k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 280k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 280k, False: 0]
| | ------------------
| | 406| 280k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
1932| |
1933| 280k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 280k| do { \
| | 657| 280k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 280k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 280k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 280k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 280k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 280k]
| | ------------------
------------------
1934| 280k| ret = fprintf(outstream, " \n",
1935| 280k| from, to);
1936| 280k| if (ret < 0) {
------------------
| Branch (1936:13): [True: 0, False: 280k]
------------------
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| 680k| for (i = 0; i < igraph_vector_int_size(&etypes); i++) {
------------------
| Branch (1940:21): [True: 400k, False: 280k]
------------------
1941| 400k| if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 60| 400k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1941:17): [True: 85.7k, False: 314k]
------------------
1942| 85.7k| name = igraph_strvector_get(&enames, i);
1943| 85.7k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, name,
------------------
| | 656| 85.7k| do { \
| | 657| 85.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 85.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 85.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 85.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| 85.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 85.7k]
| | ------------------
------------------
1944| 85.7k| igraph_ess_1(edge), &numv));
1945| 85.7k| if (!isnan(VECTOR(numv)[0])) {
------------------
| Branch (1945:21): [True: 1.22k, False: 84.5k]
------------------
1946| 1.22k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 1.22k| do { \
| | 657| 1.22k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.22k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.22k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.22k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.22k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.22k]
| | ------------------
------------------
1947| 1.22k| ret = fprintf(outstream, " ", eprefix, name_escaped);
1948| 1.22k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 1.22k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1949| 1.22k| if (ret < 0) {
------------------
| Branch (1949:25): [True: 0, False: 1.22k]
------------------
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.22k| ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 1.22k|#define VECTOR(v) ((v).stor_begin)
------------------
1953| 1.22k| if (ret < 0) {
------------------
| Branch (1953:25): [True: 0, False: 1.22k]
------------------
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.22k| ret = fprintf(outstream, "\n");
1957| 1.22k| if (ret < 0) {
------------------
| Branch (1957:25): [True: 0, False: 1.22k]
------------------
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.22k| }
1961| 314k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 60| 314k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1961:24): [True: 308k, False: 5.79k]
------------------
1962| 308k| const char *s;
1963| 308k| char *s_escaped;
1964| 308k| name = igraph_strvector_get(&enames, i);
1965| 308k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 308k| do { \
| | 657| 308k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 308k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 308k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 308k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 308k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 308k]
| | ------------------
------------------
1966| 308k| ret = fprintf(outstream, " ", eprefix,
1967| 308k| name_escaped);
1968| 308k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 308k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1969| 308k| if (ret < 0) {
------------------
| Branch (1969:21): [True: 0, False: 308k]
------------------
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| 308k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, name,
------------------
| | 656| 308k| do { \
| | 657| 308k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 308k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 308k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 308k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 308k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 308k]
| | ------------------
------------------
1973| 308k| igraph_ess_1(edge), &strv));
1974| 308k| s = igraph_strvector_get(&strv, 0);
1975| 308k| snprintf(what, sizeof(what) / sizeof(what[0]), "a value of the '%s' edge attribute", name);
1976| 308k| IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped, what));
------------------
| | 656| 308k| do { \
| | 657| 308k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 308k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 308k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 308k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 308k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 308k]
| | ------------------
------------------
1977| 308k| ret = fprintf(outstream, "%s", s_escaped);
1978| 308k| IGRAPH_FREE(s_escaped);
------------------
| | 36| 308k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1979| 308k| if (ret < 0) {
------------------
| Branch (1979:21): [True: 0, False: 308k]
------------------
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| 308k| ret = fprintf(outstream, "\n");
1983| 308k| if (ret < 0) {
------------------
| Branch (1983:21): [True: 0, False: 308k]
------------------
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| 308k| } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| | 60| 5.79k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1986:24): [True: 5.79k, False: 0]
------------------
1987| 5.79k| name = igraph_strvector_get(&enames, i);
1988| 5.79k| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph, name,
------------------
| | 656| 5.79k| do { \
| | 657| 5.79k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.79k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.79k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.79k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.79k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.79k]
| | ------------------
------------------
1989| 5.79k| igraph_ess_1(edge), &boolv));
1990| 5.79k| IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped, "edge attribute name"));
------------------
| | 656| 5.79k| do { \
| | 657| 5.79k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.79k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.79k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.79k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 5.79k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.79k]
| | ------------------
------------------
1991| 5.79k| ret = fprintf(outstream, " %s\n",
1992| 5.79k| eprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
------------------
| | 60| 5.79k|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (1992:54): [True: 0, False: 5.79k]
------------------
1993| 5.79k| IGRAPH_FREE(name_escaped);
------------------
| | 36| 5.79k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
1994| 5.79k| if (ret < 0) {
------------------
| Branch (1994:21): [True: 0, False: 5.79k]
------------------
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.79k| }
1998| 400k| }
1999| |
2000| 280k| ret = fprintf(outstream, " \n");
2001| 280k| if (ret < 0) {
------------------
| Branch (2001:13): [True: 0, False: 280k]
------------------
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| 280k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 280k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
2005| 280k| }
2006| 3.57k| igraph_eit_destroy(&it);
2007| 3.57k| IGRAPH_FINALLY_CLEAN(1);
2008| |
2009| 3.57k| ret = fprintf(outstream, " \n");
2010| 3.57k| if (ret < 0) {
------------------
| Branch (2010:9): [True: 0, False: 3.57k]
------------------
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.57k| fprintf(outstream, "\n");
2014| 3.57k| if (ret < 0) {
------------------
| Branch (2014:9): [True: 0, False: 3.57k]
------------------
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.57k| igraph_strvector_destroy(&gnames);
2019| 3.57k| igraph_strvector_destroy(&vnames);
2020| 3.57k| igraph_strvector_destroy(&enames);
2021| 3.57k| igraph_vector_int_destroy(>ypes);
2022| 3.57k| igraph_vector_int_destroy(&vtypes);
2023| 3.57k| igraph_vector_int_destroy(&etypes);
2024| 3.57k| igraph_vector_destroy(&numv);
2025| 3.57k| igraph_strvector_destroy(&strv);
2026| 3.57k| igraph_vector_bool_destroy(&boolv);
2027| 3.57k| IGRAPH_FINALLY_CLEAN(9);
2028| |
2029| 3.57k| return IGRAPH_SUCCESS;
2030| 3.57k|}
graphml.c:igraph_i_graphml_parser_state_init:
221| 24.9k|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| 24.9k| memset(state, 0, sizeof(struct igraph_i_graphml_parser_state));
223| |
224| 24.9k| state->g = graph;
225| 24.9k| state->index = index < 0 ? 0 : index;
------------------
| Branch (225:20): [True: 0, False: 24.9k]
------------------
226| 24.9k| state->successful = 1;
227| 24.9k| state->error_message = NULL;
228| |
229| 24.9k| IGRAPH_CHECK(igraph_vector_int_init(&state->prev_state_stack, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
230| 24.9k| IGRAPH_CHECK(igraph_vector_int_reserve(&state->prev_state_stack, 32));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
231| 24.9k| IGRAPH_FINALLY(igraph_vector_int_destroy, &state->prev_state_stack);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
232| |
233| 24.9k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->v_attrs, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
234| 24.9k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->v_attrs,
------------------
| | 94| 24.9k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
235| 24.9k| igraph_i_graphml_attribute_record_destroy);
236| 24.9k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->v_attrs);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
237| |
238| 24.9k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->e_attrs, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
239| 24.9k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->e_attrs,
------------------
| | 94| 24.9k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
240| 24.9k| igraph_i_graphml_attribute_record_destroy);
241| 24.9k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->e_attrs);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
242| |
243| 24.9k| IGRAPH_CHECK(igraph_vector_ptr_init(&state->g_attrs, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
244| 24.9k| IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->g_attrs,
------------------
| | 94| 24.9k| igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))
------------------
245| 24.9k| igraph_i_graphml_attribute_record_destroy);
246| 24.9k| IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->g_attrs);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
247| |
248| 24.9k| IGRAPH_CHECK(igraph_vector_int_init(&state->edgelist, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
249| 24.9k| IGRAPH_FINALLY(igraph_vector_int_destroy, &state->edgelist);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
250| |
251| 24.9k| IGRAPH_CHECK(igraph_trie_init(&state->node_trie, 1));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
252| 24.9k| IGRAPH_FINALLY(igraph_trie_destroy, &state->node_trie);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
253| |
254| 24.9k| IGRAPH_CHECK(igraph_strvector_init(&state->edgeids, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
255| 24.9k| IGRAPH_FINALLY(igraph_strvector_destroy, &state->edgeids);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
256| |
257| 24.9k| IGRAPH_CHECK(igraph_trie_init(&state->v_attr_ids, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
258| 24.9k| IGRAPH_FINALLY(igraph_trie_destroy, &state->v_attr_ids);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
259| |
260| 24.9k| IGRAPH_CHECK(igraph_trie_init(&state->e_attr_ids, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
261| 24.9k| IGRAPH_FINALLY(igraph_trie_destroy, &state->e_attr_ids);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
262| |
263| 24.9k| IGRAPH_CHECK(igraph_trie_init(&state->g_attr_ids, 0));
------------------
| | 656| 24.9k| do { \
| | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 24.9k]
| | ------------------
------------------
264| 24.9k| IGRAPH_FINALLY(igraph_trie_destroy, &state->g_attr_ids);
------------------
| | 603| 24.9k| do { \
| | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | 607| 24.9k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 24.9k]
| | ------------------
| | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 24.9k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 24.9k]
| | ------------------
------------------
265| |
266| 24.9k| IGRAPH_VECTOR_CHAR_INIT_FINALLY(&state->data_char, 0);
------------------
| | 114| 24.9k| do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
| | ------------------
| | | | 656| 24.9k| do { \
| | | | 657| 24.9k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 24.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 24.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 24.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| 24.9k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 24.9k]
| | | | ------------------
| | ------------------
| | 115| 24.9k| IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
| | ------------------
| | | | 603| 24.9k| do { \
| | | | 604| 24.9k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 24.9k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 24.9k| * incorrect destructor function with the pointer */ \
| | | | 607| 24.9k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 24.9k]
| | | | ------------------
| | | | 608| 24.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 24.9k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 24.9k]
| | | | ------------------
| | ------------------
| | | Branch (115:59): [Folded, False: 24.9k]
| | ------------------
------------------
267| |
268| 24.9k| IGRAPH_FINALLY_CLEAN(11);
269| |
270| 24.9k| return IGRAPH_SUCCESS;
271| 24.9k|}
graphml.c:igraph_i_graphml_attribute_record_destroy:
208| 18.2k|static void igraph_i_graphml_attribute_record_destroy(igraph_i_graphml_attribute_record_t* rec) {
209| 18.2k| if (!rec->record_disowned) {
------------------
| Branch (209:9): [True: 4.62k, False: 13.6k]
------------------
210| 4.62k| igraph_attribute_record_destroy(&rec->record);
211| 4.62k| }
212| |
213| 18.2k| if (rec->id != NULL) {
------------------
| Branch (213:9): [True: 17.8k, False: 340]
------------------
214| 17.8k| igraph_free(rec->id);
215| 17.8k| rec->id = NULL;
216| 17.8k| }
217| |
218| 18.2k| memset(rec, 0, sizeof(igraph_i_graphml_attribute_record_t));
219| 18.2k|}
graphml.c:igraph_i_graphml_parser_state_destroy:
273| 24.9k|static void igraph_i_graphml_parser_state_destroy(struct igraph_i_graphml_parser_state* state) {
274| 24.9k| igraph_trie_destroy(&state->node_trie);
275| 24.9k| igraph_strvector_destroy(&state->edgeids);
276| 24.9k| igraph_trie_destroy(&state->v_attr_ids);
277| 24.9k| igraph_trie_destroy(&state->e_attr_ids);
278| 24.9k| igraph_trie_destroy(&state->g_attr_ids);
279| 24.9k| igraph_vector_int_destroy(&state->edgelist);
280| 24.9k| igraph_vector_int_destroy(&state->prev_state_stack);
281| |
282| 24.9k| igraph_vector_ptr_destroy_all(&state->v_attrs);
283| 24.9k| igraph_vector_ptr_destroy_all(&state->e_attrs);
284| 24.9k| igraph_vector_ptr_destroy_all(&state->g_attrs);
285| |
286| 24.9k| igraph_vector_char_destroy(&state->data_char);
287| |
288| 24.9k| if (state->data_key) {
------------------
| Branch (288:9): [True: 3.70k, False: 21.2k]
------------------
289| 3.70k| xmlFree((void *) state->data_key);
290| 3.70k| state->data_key = NULL;
291| 3.70k| }
292| |
293| 24.9k| if (state->error_message) {
------------------
| Branch (293:9): [True: 17.8k, False: 7.11k]
------------------
294| | IGRAPH_FREE(state->error_message);
------------------
| | 36| 17.8k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
295| 17.8k| }
296| 24.9k|}
graphml.c:igraph_i_graphml_parser_state_set_error_from_varargs:
300| 650|) {
301| 650| const size_t max_error_message_length = 4096;
302| |
303| 650| state->successful = 0;
304| 650| state->st = ERROR;
305| |
306| 650| if (state->error_message == 0) {
------------------
| Branch (306:9): [True: 636, False: 14]
------------------
307| | /* ownership of state->error_message passed on immediately to
308| | * state so the state destructor is responsible for freeing it */
309| 636| state->error_message = IGRAPH_CALLOC(max_error_message_length, char);
------------------
| | 33| 636|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.27k| (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: 636, Folded]
| | | | ------------------
| | ------------------
------------------
310| 636| }
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| 650| if (state->error_message != 0) {
------------------
| Branch (314:9): [True: 650, False: 0]
------------------
315| 650| vsnprintf(state->error_message, max_error_message_length, msg, args);
316| 650| }
317| 650|}
graphml.c:igraph_i_libxml_structured_error_handler:
1429| 243k|static void igraph_i_libxml_structured_error_handler(void* ctx, const xmlError *error) {
1430| 243k|#endif
1431| 243k| struct igraph_i_graphml_parser_state* state = (struct igraph_i_graphml_parser_state*) ctx;
1432| 243k| igraph_i_graphml_parser_state_set_error_from_xmlerror(state, error);
1433| 243k|}
graphml.c:igraph_i_graphml_parser_state_set_error_from_xmlerror:
321| 243k|) {
322| 243k| const size_t max_error_message_length = 4096;
323| |
324| 243k| state->successful = 0;
325| 243k| state->st = ERROR;
326| |
327| 243k| if (state->error_message == 0) {
------------------
| Branch (327:9): [True: 17.1k, False: 226k]
------------------
328| | /* ownership of state->error_message passed on immediately to
329| | * state so the state destructor is responsible for freeing it */
330| 17.1k| state->error_message = IGRAPH_CALLOC(max_error_message_length, char);
------------------
| | 33| 17.1k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 34.3k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 0, Folded]
| | | | | Branch (31:24): [True: 0, Folded]
| | | | | Branch (31:66): [True: 17.1k, Folded]
| | | | ------------------
| | ------------------
------------------
331| 17.1k| }
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| 243k| if (state->error_message != 0) {
------------------
| Branch (335:9): [True: 243k, False: 0]
------------------
336| 243k| snprintf(state->error_message, max_error_message_length, "Line %d: %s",
337| 243k| error->line, error->message);
338| 243k| }
339| 243k|}
graphml.c:igraph_i_graphml_sax_handler_get_entity:
351| 19.9k| const xmlChar* name) {
352| 19.9k| xmlEntityPtr predef = xmlGetPredefinedEntity(name);
353| 19.9k| const char* entityName;
354| |
355| 19.9k| IGRAPH_UNUSED(state0);
------------------
| | 30| 19.9k|#define IGRAPH_UNUSED(x) (void)(x)
------------------
356| 19.9k| if (predef != NULL) {
------------------
| Branch (356:9): [True: 5.70k, False: 14.1k]
------------------
357| 5.70k| return predef;
358| 5.70k| }
359| |
360| 14.1k| entityName = fromXmlChar(name);
------------------
| | 76| 14.1k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
361| 14.1k| IGRAPH_WARNINGF("Unknown XML entity found: '%s'.", entityName);
------------------
| | 777| 14.1k| do { \
| | 778| 14.1k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 14.1k| __VA_ARGS__); \
| | 780| 14.1k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 14.1k]
| | ------------------
------------------
362| |
363| 14.1k| return &blankEntity;
364| 19.9k|}
graphml.c:igraph_i_graphml_sax_handler_start_document:
377| 24.1k|static void igraph_i_graphml_sax_handler_start_document(void *state0) {
378| 24.1k| struct igraph_i_graphml_parser_state *state =
379| 24.1k| (struct igraph_i_graphml_parser_state*)state0;
380| |
381| 24.1k| state->st = START;
382| 24.1k| state->successful = 1;
383| 24.1k| state->edges_directed = 0;
384| | state->data_key = NULL;
385| 24.1k| state->unknown_depth = 0;
386| 24.1k| state->ignore_namespaces = 0;
387| 24.1k|}
graphml.c:igraph_i_graphml_sax_handler_chars:
1298| 42.5M|static void igraph_i_graphml_sax_handler_chars(void* state0, const xmlChar* ch, int len) {
1299| 42.5M| struct igraph_i_graphml_parser_state *state =
1300| 42.5M| (struct igraph_i_graphml_parser_state*)state0;
1301| 42.5M| igraph_error_t result = IGRAPH_SUCCESS;
1302| |
1303| 42.5M| if (!state->successful) {
------------------
| Branch (1303:9): [True: 10.7k, False: 42.5M]
------------------
1304| 10.7k| return;
1305| 10.7k| }
1306| |
1307| 42.5M| switch (state->st) {
1308| 2.66k| case INSIDE_KEY:
------------------
| Branch (1308:5): [True: 2.66k, False: 42.5M]
------------------
1309| 2.66k| break;
1310| |
1311| 40.9M| case INSIDE_DATA:
------------------
| Branch (1311:5): [True: 40.9M, False: 1.59M]
------------------
1312| 40.9M| case INSIDE_DEFAULT:
------------------
| Branch (1312:5): [True: 12.6k, False: 42.5M]
------------------
1313| 40.9M| result = igraph_i_graphml_append_to_data_char(state, ch, len);
1314| 40.9M| break;
1315| |
1316| 1.58M| default:
------------------
| Branch (1316:5): [True: 1.58M, False: 40.9M]
------------------
1317| | /* just ignore it */
1318| 1.58M| break;
1319| 42.5M| }
1320| |
1321| 42.5M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1321:9): [True: 0, False: 42.5M]
------------------
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.5M|}
graphml.c:igraph_i_graphml_append_to_data_char:
780| 40.9M|) {
781| 40.9M| const igraph_vector_char_t data_vec =
782| 40.9M| igraph_vector_char_view((char *) data, len);
783| |
784| 40.9M| if (!state->successful) {
------------------
| Branch (784:9): [True: 0, False: 40.9M]
------------------
785| 0| return IGRAPH_SUCCESS;
786| 0| }
787| |
788| 40.9M| IGRAPH_STATIC_ASSERT(sizeof(char) == sizeof(xmlChar));
------------------
| | 68| 40.9M|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
789| 40.9M| IGRAPH_CHECK(igraph_vector_char_append(
------------------
| | 656| 40.9M| do { \
| | 657| 40.9M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 40.9M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 40.9M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 40.9M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.9M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 40.9M]
| | ------------------
------------------
790| 40.9M| &state->data_char,
791| 40.9M| &data_vec
792| 40.9M| ));
793| |
794| 40.9M| return IGRAPH_SUCCESS;
795| 40.9M|}
graphml.c:igraph_i_graphml_sax_handler_error:
341| 650|static void igraph_i_graphml_sax_handler_error(void *state0, const char* msg, ...) {
342| 650| struct igraph_i_graphml_parser_state *state =
343| 650| (struct igraph_i_graphml_parser_state*)state0;
344| 650| va_list args;
345| 650| va_start(args, msg);
346| 650| igraph_i_graphml_parser_state_set_error_from_varargs(state, msg, args);
347| | va_end(args);
348| 650|}
graphml.c:igraph_i_graphml_sax_handler_start_element_ns:
1198| 4.63M| int nb_attributes, int nb_defaulted, const xmlChar** attributes) {
1199| 4.63M| struct igraph_i_graphml_parser_state *state =
1200| 4.63M| (struct igraph_i_graphml_parser_state*)state0;
1201| 4.63M| igraph_error_t result;
1202| |
1203| 4.63M| if (!state->successful) {
------------------
| Branch (1203:9): [True: 60.6k, False: 4.56M]
------------------
1204| 60.6k| return;
1205| 60.6k| }
1206| |
1207| 4.56M| result = igraph_i_graphml_sax_handler_start_element_ns_inner(
1208| 4.56M| state, localname, prefix, uri, nb_namespaces, namespaces,
1209| 4.56M| nb_attributes, nb_defaulted, attributes
1210| 4.56M| );
1211| |
1212| 4.56M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1212:9): [True: 528, False: 4.56M]
------------------
1213| 528| RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file.", result);
------------------
| | 85| 528| do { \
| | 86| 528| GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code); \
| | ------------------
| | | | 79| 528| do { \
| | | | 80| 528| if (state->successful) { \
| | | | ------------------
| | | | | Branch (80:13): [True: 528, False: 0]
| | | | ------------------
| | | | 81| 528| igraph_i_graphml_sax_handler_error(state, msg); \
| | | | 82| 528| } \
| | | | 83| 528| } while (0)
| | | | ------------------
| | | | | Branch (83:14): [Folded, False: 528]
| | | | ------------------
| | ------------------
| | 87| 528| return; \
| | 88| 528| } while (0)
| | ------------------
| | | Branch (88:14): [Folded, False: 0]
| | ------------------
------------------
1214| 528| }
1215| 4.56M|}
graphml.c:igraph_i_graphml_sax_handler_start_element_ns_inner:
946| 4.56M| int nb_attributes, int nb_defaulted, const xmlChar** attributes) {
947| 4.56M| xmlChar** it;
948| 4.56M| xmlChar* attr_value = 0;
949| 4.56M| igraph_int_t id1, id2;
950| 4.56M| int i;
951| 4.56M| igraph_bool_t tag_is_unknown = false;
952| |
953| 4.56M| IGRAPH_UNUSED(prefix);
------------------
| | 30| 4.56M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
954| 4.56M| IGRAPH_UNUSED(nb_namespaces);
------------------
| | 30| 4.56M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
955| 4.56M| IGRAPH_UNUSED(namespaces);
------------------
| | 30| 4.56M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
956| 4.56M| IGRAPH_UNUSED(nb_defaulted);
------------------
| | 30| 4.56M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
957| |
958| 4.56M| if (uri) {
------------------
| Branch (958:9): [True: 869k, False: 3.70M]
------------------
959| 869k| if (!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), uri)) {
------------------
| | 75| 869k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 869k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (959:13): [True: 7.68k, False: 861k]
------------------
960| | /* Tag is in a different namespace, so treat it as an unknown start
961| | * tag irrespectively of our state */
962| 7.68k| tag_is_unknown = 1;
963| 7.68k| }
964| 3.70M| } 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.70M| if (!state->ignore_namespaces && state->st != START) {
------------------
| Branch (971:13): [True: 3.45M, False: 246k]
| Branch (971:42): [True: 3.44M, False: 7.21k]
------------------
972| 3.44M| tag_is_unknown = 1;
973| 3.44M| }
974| 3.70M| }
975| |
976| 4.56M| if (tag_is_unknown) {
------------------
| Branch (976:9): [True: 3.45M, False: 1.11M]
------------------
977| 3.45M| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 3.45M| do { \
| | 657| 3.45M| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.45M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.45M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.45M]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.45M| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.45M]
| | ------------------
------------------
978| 3.45M| goto exit;
979| 3.45M| }
980| |
981| 1.11M| switch (state->st) {
982| 11.1k| case START:
------------------
| Branch (982:5): [True: 11.1k, False: 1.10M]
------------------
983| | /* If we are in the START state and received a graphml tag,
984| | * change to INSIDE_GRAPHML state. Otherwise, change to UNKNOWN. */
985| 11.1k| if (xmlStrEqual(localname, toXmlChar("graphml"))) {
------------------
| | 75| 11.1k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 11.1k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (985:13): [True: 8.61k, False: 2.56k]
------------------
986| 8.61k| if (uri == 0) {
------------------
| Branch (986:17): [True: 4.65k, False: 3.95k]
------------------
987| 4.65k| state->ignore_namespaces = 1;
988| 4.65k| }
989| 8.61k| state->st = INSIDE_GRAPHML;
990| 8.61k| } else {
991| 2.56k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 2.56k| do { \
| | 657| 2.56k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 2.56k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 2.56k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 2.56k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.56k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 2.56k]
| | ------------------
------------------
992| 2.56k| }
993| 11.1k| break;
994| |
995| 29.4k| case INSIDE_GRAPHML:
------------------
| Branch (995:5): [True: 29.4k, False: 1.08M]
------------------
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| 29.4k| if (xmlStrEqual(localname, toXmlChar("graph"))) {
------------------
| | 75| 29.4k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 29.4k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1000:13): [True: 10.1k, False: 19.3k]
------------------
1001| 10.1k| if (state->index == 0) {
------------------
| Branch (1001:17): [True: 7.68k, False: 2.42k]
------------------
1002| 7.68k| state->st = INSIDE_GRAPH;
1003| 16.7k| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1003:57): [True: 9.07k, False: 7.68k]
------------------
1004| 9.07k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 9.07k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1004:25): [True: 20, False: 9.05k]
------------------
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| 9.06k| if (xmlStrEqual(*it, toXmlChar("edgedefault"))) {
------------------
| | 75| 9.06k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 9.06k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1009:25): [True: 3.81k, False: 5.24k]
------------------
1010| 3.81k| if (xmlAttrValueEqual(it, "directed")) {
------------------
| Branch (1010:29): [True: 276, False: 3.54k]
------------------
1011| 276| state->edges_directed = 1;
1012| 3.54k| } else if (xmlAttrValueEqual(it, "undirected")) {
------------------
| Branch (1012:36): [True: 3.45k, False: 85]
------------------
1013| 3.45k| state->edges_directed = 0;
1014| 3.45k| }
1015| 3.81k| }
1016| 9.06k| }
1017| 7.68k| }
1018| 10.1k| state->index--;
1019| 19.3k| } else if (xmlStrEqual(localname, toXmlChar("key"))) {
------------------
| | 75| 19.3k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 19.3k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1019:20): [True: 18.2k, False: 1.11k]
------------------
1020| 18.2k| IGRAPH_CHECK(
------------------
| | 656| 18.2k| do { \
| | 657| 18.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 18.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 18.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 440, False: 17.7k]
| | | | ------------------
| | ------------------
| | 659| 440| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 440| do { \
| | | | 427| 440| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 440| return igraph_errno ; \
| | | | 429| 440| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 440| } \
| | 661| 18.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.7k]
| | ------------------
------------------
1021| 18.2k| igraph_i_graphml_add_attribute_key(
1022| 18.2k| &state->current_attr_record,
1023| 18.2k| attributes, nb_attributes, state
1024| 18.2k| )
1025| 18.2k| );
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| 17.7k| state->st = INSIDE_KEY;
1030| 17.7k| } else {
1031| 1.11k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 1.11k| do { \
| | 657| 1.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.11k]
| | ------------------
------------------
1032| 1.11k| }
1033| 29.0k| break;
1034| |
1035| 29.0k| case INSIDE_KEY:
------------------
| Branch (1035:5): [True: 4.65k, False: 1.11M]
------------------
1036| | /* If we are in the INSIDE_KEY state and we are not skipping the current
1037| | * attribute, check for default tag */
1038| 4.65k| if (state->current_attr_record != NULL && xmlStrEqual(localname, toXmlChar("default"))) {
------------------
| | 75| 4.30k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 4.30k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1038:13): [True: 4.30k, False: 352]
| Branch (1038:51): [True: 4.06k, False: 240]
------------------
1039| 4.06k| state->st = INSIDE_DEFAULT;
1040| 4.06k| } else {
1041| 592| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 592| do { \
| | 657| 592| igraph_error_t igraph_i_ret = (expr); \
| | 658| 592| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 592| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 592]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 592| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 592]
| | ------------------
------------------
1042| 592| }
1043| 4.65k| break;
1044| |
1045| 4.65k| case INSIDE_DEFAULT:
------------------
| Branch (1045:5): [True: 404, False: 1.11M]
------------------
1046| | /* If we are in the INSIDE_DEFAULT state, every further tag will be unknown */
1047| 404| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 404| do { \
| | 657| 404| igraph_error_t igraph_i_ret = (expr); \
| | 658| 404| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 404| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 404]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 404| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 404]
| | ------------------
------------------
1048| 404| break;
1049| |
1050| 612k| case INSIDE_GRAPH:
------------------
| Branch (1050:5): [True: 612k, False: 502k]
------------------
1051| | /* If we are in the INSIDE_GRAPH state, check for node and edge tags */
1052| 612k| if (xmlStrEqual(localname, toXmlChar("edge"))) {
------------------
| | 75| 612k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 612k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1052:13): [True: 570k, False: 42.1k]
------------------
1053| 570k| id1 = -1; id2 = -1;
1054| 1.83M| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1054:53): [True: 1.26M, False: 570k]
------------------
1055| 1.26M| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 1.26M|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1055:21): [True: 76, False: 1.26M]
------------------
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.26M| if (xmlStrEqual(*it, toXmlChar("source"))) {
------------------
| | 75| 1.26M|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 1.26M|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1060:21): [True: 570k, False: 690k]
------------------
1061| 570k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 570k|#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| 570k| if (attr_value == 0) {
------------------
| Branch (1062:25): [True: 0, False: 570k]
------------------
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| 570k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 570k| do { \
| | 604| 570k| /* the following branch makes the compiler check the compatibility of \
| | 605| 570k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 570k| * incorrect destructor function with the pointer */ \
| | 607| 570k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 570k]
| | ------------------
| | 608| 570k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 570k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 570k]
| | ------------------
------------------
1066| |
1067| 570k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id1));
------------------
| | 656| 570k| do { \
| | 657| 570k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 570k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 570k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 570k]
| | | | ------------------
| | ------------------
| | 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| 570k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 570k]
| | ------------------
------------------
1068| |
1069| 570k| xmlFree(attr_value); attr_value = NULL;
1070| 570k| IGRAPH_FINALLY_CLEAN(1);
1071| 690k| } else if (xmlStrEqual(*it, toXmlChar("target"))) {
------------------
| | 75| 690k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 690k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1071:28): [True: 570k, False: 119k]
------------------
1072| 570k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 570k|#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| 570k| if (attr_value == 0) {
------------------
| Branch (1073:25): [True: 0, False: 570k]
------------------
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| 570k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 570k| do { \
| | 604| 570k| /* the following branch makes the compiler check the compatibility of \
| | 605| 570k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 570k| * incorrect destructor function with the pointer */ \
| | 607| 570k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 570k]
| | ------------------
| | 608| 570k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 570k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 570k]
| | ------------------
------------------
1077| |
1078| 570k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id2));
------------------
| | 656| 570k| do { \
| | 657| 570k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 570k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 570k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 1, False: 570k]
| | | | ------------------
| | ------------------
| | 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| 570k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 570k]
| | ------------------
------------------
1079| |
1080| 570k| xmlFree(attr_value); attr_value = NULL;
1081| 570k| IGRAPH_FINALLY_CLEAN(1);
1082| 570k| } else if (xmlStrEqual(*it, toXmlChar("id"))) {
------------------
| | 75| 119k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 119k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1082:28): [True: 114k, False: 5.04k]
------------------
1083| 114k| igraph_int_t edges = igraph_vector_int_size(&state->edgelist) / 2 + 1;
1084| 114k| igraph_int_t origsize = igraph_strvector_size(&state->edgeids);
1085| |
1086| 114k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 114k|#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| 114k| if (attr_value == 0) {
------------------
| Branch (1087:25): [True: 0, False: 114k]
------------------
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| 114k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 114k| do { \
| | 604| 114k| /* the following branch makes the compiler check the compatibility of \
| | 605| 114k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 114k| * incorrect destructor function with the pointer */ \
| | 607| 114k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 114k]
| | ------------------
| | 608| 114k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 114k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 114k]
| | ------------------
------------------
1091| |
1092| 114k| IGRAPH_CHECK(igraph_strvector_resize(&state->edgeids, edges));
------------------
| | 656| 114k| do { \
| | 657| 114k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 114k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 114k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 114k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 114k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 114k]
| | ------------------
------------------
1093| |
1094| 159k| for (; origsize < edges - 1; origsize++) {
------------------
| Branch (1094:28): [True: 44.6k, False: 114k]
------------------
1095| 44.6k| IGRAPH_CHECK(igraph_strvector_set(&state->edgeids, origsize, ""));
------------------
| | 656| 44.6k| do { \
| | 657| 44.6k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 44.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 44.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 44.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| 44.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 44.6k]
| | ------------------
------------------
1096| 44.6k| }
1097| |
1098| 114k| IGRAPH_CHECK(igraph_strvector_set(&state->edgeids, edges - 1, fromXmlChar(attr_value)));
------------------
| | 656| 114k| do { \
| | 657| 114k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 114k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 114k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 114k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 114k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 114k]
| | ------------------
------------------
1099| |
1100| 114k| xmlFree(attr_value); attr_value = NULL;
1101| 114k| IGRAPH_FINALLY_CLEAN(1);
1102| 114k| }
1103| 1.26M| }
1104| 570k| if (id1 >= 0 && id2 >= 0) {
------------------
| Branch (1104:17): [True: 570k, False: 51]
| Branch (1104:29): [True: 570k, False: 14]
------------------
1105| 570k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->edgelist, id1));
------------------
| | 656| 570k| do { \
| | 657| 570k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 570k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 570k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 570k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 570k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 570k]
| | ------------------
------------------
1106| 570k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->edgelist, id2));
------------------
| | 656| 570k| do { \
| | 657| 570k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 570k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 570k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 570k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 570k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 570k]
| | ------------------
------------------
1107| 570k| } else {
1108| 65| IGRAPH_ERROR("Edge with missing source or target encountered.", 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]
| | ------------------
------------------
1109| 65| }
1110| 570k| state->st = INSIDE_EDGE;
1111| 570k| } else if (xmlStrEqual(localname, toXmlChar("node"))) {
------------------
| | 75| 42.1k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 42.1k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1111:20): [True: 34.1k, False: 8.02k]
------------------
1112| 34.1k| id1 = -1;
1113| 34.8k| for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
------------------
| Branch (1113:53): [True: 34.8k, False: 19]
------------------
1114| 34.8k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 34.8k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1114:21): [True: 205, False: 34.6k]
------------------
1115| 205| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 205|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 205|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 205|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (1115:21): [True: 195, False: 10]
------------------
1116| | /* Attribute is from a different namespace, so skip it */
1117| 195| continue;
1118| 195| }
1119| 34.6k| if (xmlStrEqual(XML_ATTR_LOCALNAME(it), toXmlChar("id"))) {
------------------
| | 495| 34.6k|#define XML_ATTR_LOCALNAME(it) it[0]
------------------
if (xmlStrEqual(XML_ATTR_LOCALNAME(it), toXmlChar("id"))) {
------------------
| | 75| 34.6k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 34.6k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1119:21): [True: 34.0k, False: 531]
------------------
1120| 34.0k| attr_value = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 34.0k|#define XML_ATTR_VALUE(it) it[3], (int)(it[4] - it[3]) /* for use in strnxxx()-style functions that take a char * and a length */
------------------
1121| 34.0k| if (attr_value == 0) {
------------------
| Branch (1121:25): [True: 0, False: 34.0k]
------------------
1122| 0| IGRAPH_ERROR("Cannot copy value of node ID attribute.", IGRAPH_ENOMEM);
------------------
| | 426| 0| do { \
| | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 0| return igraph_errno ; \
| | 429| 0| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
1123| 0| }
1124| 34.0k| IGRAPH_FINALLY(xmlFree, attr_value);
------------------
| | 603| 34.0k| do { \
| | 604| 34.0k| /* the following branch makes the compiler check the compatibility of \
| | 605| 34.0k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 34.0k| * incorrect destructor function with the pointer */ \
| | 607| 34.0k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 34.0k]
| | ------------------
| | 608| 34.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 34.0k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 34.0k]
| | ------------------
------------------
1125| |
1126| 34.0k| IGRAPH_CHECK(igraph_trie_get(&state->node_trie, fromXmlChar(attr_value), &id1));
------------------
| | 656| 34.0k| do { \
| | 657| 34.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 34.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 34.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 2, False: 34.0k]
| | | | ------------------
| | ------------------
| | 659| 2| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 2| do { \
| | | | 427| 2| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 2| return igraph_errno ; \
| | | | 429| 2| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 2| } \
| | 661| 34.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 34.0k]
| | ------------------
------------------
1127| |
1128| 34.0k| xmlFree(attr_value); attr_value = NULL;
1129| 34.0k| IGRAPH_FINALLY_CLEAN(1);
1130| 34.0k| break;
1131| 34.0k| }
1132| 34.6k| }
1133| 34.1k| if (id1 >= 0) {
------------------
| Branch (1133:17): [True: 34.0k, False: 19]
------------------
1134| 34.0k| state->act_node = id1;
1135| 34.0k| } 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| 34.0k| state->st = INSIDE_NODE;
1140| 34.0k| } else if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 8.02k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 8.02k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1140:20): [True: 3.28k, False: 4.73k]
------------------
1141| 3.28k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 656| 3.28k| do { \
| | 657| 3.28k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.28k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.28k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.28k]
| | ------------------
------------------
1142| 3.28k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_GRAPH
1143| 3.28k| ));
1144| 3.28k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 3.28k| do { \
| | 657| 3.28k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.28k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.28k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.28k]
| | ------------------
------------------
1145| 3.28k| state->st = INSIDE_DATA;
1146| 4.73k| } else {
1147| 4.73k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 4.73k| do { \
| | 657| 4.73k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.73k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.73k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.73k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.73k]
| | ------------------
------------------
1148| 4.73k| }
1149| 612k| break;
1150| |
1151| 612k| case INSIDE_NODE:
------------------
| Branch (1151:5): [True: 51.3k, False: 1.06M]
------------------
1152| 51.3k| if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 51.3k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 51.3k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1152:13): [True: 51.1k, False: 229]
------------------
1153| 51.1k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 656| 51.1k| do { \
| | 657| 51.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.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| 51.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.1k]
| | ------------------
------------------
1154| 51.1k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_VERTEX
1155| 51.1k| ));
1156| 51.1k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 51.1k| do { \
| | 657| 51.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51.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| 51.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51.1k]
| | ------------------
------------------
1157| 51.1k| state->st = INSIDE_DATA;
1158| 51.1k| } else {
1159| 229| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 229| do { \
| | 657| 229| igraph_error_t igraph_i_ret = (expr); \
| | 658| 229| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 229| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 229]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 229| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 229]
| | ------------------
------------------
1160| 229| }
1161| 51.3k| break;
1162| |
1163| 316k| case INSIDE_EDGE:
------------------
| Branch (1163:5): [True: 316k, False: 798k]
------------------
1164| 316k| if (xmlStrEqual(localname, toXmlChar("data"))) {
------------------
| | 75| 316k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 316k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (1164:13): [True: 316k, False: 441]
------------------
1165| 316k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_setup(
------------------
| | 656| 316k| do { \
| | 657| 316k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 316k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 316k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 316k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 316k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 316k]
| | ------------------
------------------
1166| 316k| state, attributes, nb_attributes, IGRAPH_ATTRIBUTE_EDGE
1167| 316k| ));
1168| 316k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 316k| do { \
| | 657| 316k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 316k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 316k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 316k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 316k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 316k]
| | ------------------
------------------
1169| 316k| state->st = INSIDE_DATA;
1170| 316k| } else {
1171| 441| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 441| do { \
| | 657| 441| igraph_error_t igraph_i_ret = (expr); \
| | 658| 441| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 441| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 441]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 441| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 441]
| | ------------------
------------------
1172| 441| }
1173| 316k| break;
1174| |
1175| 316k| case INSIDE_DATA:
------------------
| Branch (1175:5): [True: 381, False: 1.11M]
------------------
1176| | /* We do not expect any new tags within a tag */
1177| 381| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 381| do { \
| | 657| 381| igraph_error_t igraph_i_ret = (expr); \
| | 658| 381| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 381| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 381]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 381| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 381]
| | ------------------
------------------
1178| 381| break;
1179| |
1180| 87.2k| case UNKNOWN:
------------------
| Branch (1180:5): [True: 87.2k, False: 1.02M]
------------------
1181| 87.2k| IGRAPH_CHECK(igraph_i_graphml_handle_unknown_start_tag(state));
------------------
| | 656| 87.2k| do { \
| | 657| 87.2k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 87.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 87.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 87.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| 87.2k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 87.2k]
| | ------------------
------------------
1182| 87.2k| break;
1183| |
1184| 87.2k| case FINISH:
------------------
| Branch (1184:5): [True: 1.12k, False: 1.11M]
------------------
1185| 1.12k| break;
1186| |
1187| 0| default:
------------------
| Branch (1187:5): [True: 0, False: 1.11M]
------------------
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.11M| }
1190| |
1191| 4.56M|exit:
1192| 4.56M| return IGRAPH_SUCCESS;
1193| 1.11M|}
graphml.c:igraph_i_graphml_handle_unknown_start_tag:
366| 3.55M|static igraph_error_t igraph_i_graphml_handle_unknown_start_tag(struct igraph_i_graphml_parser_state *state) {
367| 3.55M| if (state->st != UNKNOWN) {
------------------
| Branch (367:9): [True: 10.7k, False: 3.54M]
------------------
368| 10.7k| IGRAPH_CHECK(igraph_vector_int_push_back(&state->prev_state_stack, state->st));
------------------
| | 656| 10.7k| do { \
| | 657| 10.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10.7k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 10.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.7k]
| | ------------------
------------------
369| 10.7k| state->st = UNKNOWN;
370| 10.7k| state->unknown_depth = 1;
371| 3.54M| } else {
372| 3.54M| state->unknown_depth++;
373| 3.54M| }
374| 3.55M| return IGRAPH_SUCCESS;
375| 3.55M|}
graphml.c:xmlAttrValueEqual:
532| 84.9k|static igraph_bool_t xmlAttrValueEqual(xmlChar** attr, const char* expected) {
533| 84.9k| size_t expected_length = strlen(expected);
534| 84.9k| return (
535| 84.9k| expected_length == XML_ATTR_VALUE_LENGTH(attr) &&
------------------
| | 500| 169k|#define XML_ATTR_VALUE_LENGTH(it) (size_t)(it[4] - it[3])
------------------
| Branch (535:9): [True: 44.1k, False: 40.7k]
------------------
536| 44.1k| !xmlStrncmp(toXmlChar(expected), XML_ATTR_VALUE(attr))
------------------
| | 75| 44.1k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 44.1k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrncmp(toXmlChar(expected), XML_ATTR_VALUE(attr))
------------------
| | 501| 44.1k|#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: 35.1k, False: 8.98k]
------------------
537| 84.9k| );
538| 84.9k|}
graphml.c:igraph_i_graphml_add_attribute_key:
544| 18.2k|) {
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| 18.2k| xmlChar **it;
559| 18.2k| xmlChar *localname;
560| 18.2k| igraph_trie_t *trie = NULL;
561| 18.2k| igraph_vector_ptr_t *ptrvector = NULL;
562| 18.2k| igraph_int_t i, n;
563| 18.2k| igraph_int_t id;
564| 18.2k| igraph_i_graphml_attribute_record_t *rec = NULL;
565| 18.2k| char *attr_name;
566| 18.2k| igraph_attribute_type_t igraph_attr_type;
567| 18.2k| igraph_bool_t skip = false;
568| |
569| 18.2k| attr_name = NULL;
570| 18.2k| IGRAPH_FINALLY(safely_free_optional_string, &attr_name);
------------------
| | 603| 18.2k| do { \
| | 604| 18.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 18.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 18.2k| * incorrect destructor function with the pointer */ \
| | 607| 18.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 18.2k]
| | ------------------
| | 608| 18.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 18.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 18.2k]
| | ------------------
------------------
571| |
572| 18.2k| if (!state->successful) {
------------------
| Branch (572:9): [True: 0, False: 18.2k]
------------------
573| | /* Parser is already in an error state */
574| 0| goto exit;
575| 0| }
576| |
577| 18.2k| rec = IGRAPH_CALLOC(1, igraph_i_graphml_attribute_record_t);
------------------
| | 33| 18.2k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 36.4k| (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: 18.2k, Folded]
| | | | ------------------
| | ------------------
------------------
578| 18.2k| IGRAPH_CHECK_OOM(rec, "Insufficient memory to allocate attribute record.");
------------------
| | 709| 18.2k| do { \
| | 710| 18.2k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 18.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 18.2k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 18.2k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 18.2k]
| | ------------------
------------------
579| 18.2k| IGRAPH_FINALLY(igraph_free, rec);
------------------
| | 603| 18.2k| do { \
| | 604| 18.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 18.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 18.2k| * incorrect destructor function with the pointer */ \
| | 607| 18.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 18.2k]
| | ------------------
| | 608| 18.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 18.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 18.2k]
| | ------------------
------------------
580| 18.2k| IGRAPH_FINALLY(igraph_i_graphml_attribute_record_destroy, rec);
------------------
| | 603| 18.2k| do { \
| | 604| 18.2k| /* the following branch makes the compiler check the compatibility of \
| | 605| 18.2k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 18.2k| * incorrect destructor function with the pointer */ \
| | 607| 18.2k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 18.2k]
| | ------------------
| | 608| 18.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 18.2k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 18.2k]
| | ------------------
------------------
581| 18.2k| memset(rec, 0, sizeof(igraph_i_graphml_attribute_record_t));
582| |
583| 18.2k| igraph_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
584| |
585| 81.9k| for (i = 0, it = (xmlChar**)attrs; i < nb_attrs; i++, it += 5) {
------------------
| Branch (585:40): [True: 63.9k, False: 17.9k]
------------------
586| 63.9k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 63.9k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (586:13): [True: 481, False: 63.5k]
------------------
587| 481| !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 75| 481|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 481|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
------------------
| | 497| 481|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (587:13): [True: 413, False: 68]
------------------
588| 413| continue;
589| 413| }
590| |
591| 63.5k| localname = XML_ATTR_LOCALNAME(it);
------------------
| | 495| 63.5k|#define XML_ATTR_LOCALNAME(it) it[0]
------------------
592| |
593| 63.5k| if (xmlStrEqual(localname, toXmlChar("id"))) {
------------------
| | 75| 63.5k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 63.5k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (593:13): [True: 17.9k, False: 45.6k]
------------------
594| 17.9k| safely_free_optional_string(&rec->id);
595| 17.9k| IGRAPH_CHECK(safely_convert_xml_attribute_to_string(it, &rec->id));
------------------
| | 656| 17.9k| do { \
| | 657| 17.9k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 17.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 17.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 17.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| 17.9k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 17.9k]
| | ------------------
------------------
596| 45.6k| } else if (xmlStrEqual(localname, toXmlChar("attr.name"))) {
------------------
| | 75| 45.6k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 45.6k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (596:20): [True: 10.5k, False: 35.0k]
------------------
597| 10.5k| safely_free_optional_string(&attr_name);
598| 10.5k| IGRAPH_CHECK(safely_convert_xml_attribute_to_string(it, &attr_name));
------------------
| | 656| 10.5k| do { \
| | 657| 10.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10.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| 10.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.5k]
| | ------------------
------------------
599| 35.0k| } else if (xmlStrEqual(localname, toXmlChar("attr.type"))) {
------------------
| | 75| 35.0k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 35.0k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (599:20): [True: 15.2k, False: 19.8k]
------------------
600| 15.2k| if (xmlAttrValueEqual(it, "boolean")) {
------------------
| Branch (600:17): [True: 2.88k, False: 12.3k]
------------------
601| 2.88k| igraph_attr_type = IGRAPH_ATTRIBUTE_BOOLEAN;
602| 2.88k| rec->type = I_GRAPHML_BOOLEAN;
603| 12.3k| } else if (xmlAttrValueEqual(it, "string")) {
------------------
| Branch (603:24): [True: 9.65k, False: 2.69k]
------------------
604| 9.65k| igraph_attr_type = IGRAPH_ATTRIBUTE_STRING;
605| 9.65k| rec->type = I_GRAPHML_STRING;
606| 9.65k| } else if (xmlAttrValueEqual(it, "float")) {
------------------
| Branch (606:24): [True: 83, False: 2.60k]
------------------
607| 83| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
608| 83| rec->type = I_GRAPHML_FLOAT;
609| 2.60k| } else if (xmlAttrValueEqual(it, "double")) {
------------------
| Branch (609:24): [True: 2.02k, False: 581]
------------------
610| 2.02k| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
611| 2.02k| rec->type = I_GRAPHML_DOUBLE;
612| 2.02k| } else if (xmlAttrValueEqual(it, "int")) {
------------------
| Branch (612:24): [True: 219, False: 362]
------------------
613| 219| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
614| 219| rec->type = I_GRAPHML_INTEGER;
615| 362| } else if (xmlAttrValueEqual(it, "long")) {
------------------
| Branch (615:24): [True: 199, False: 163]
------------------
616| 199| igraph_attr_type = IGRAPH_ATTRIBUTE_NUMERIC;
617| 199| rec->type = I_GRAPHML_LONG;
618| 199| } else {
619| 163| IGRAPH_ERRORF("Unknown attribute type '%.*s'.", IGRAPH_PARSEERROR,
------------------
| | 464| 163| do { \
| | 465| 163| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 163| igraph_errno, __VA_ARGS__) ; \
| | 467| 163| return igraph_errno; \
| | 468| 163| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
620| 163| XML_ATTR_VALUE_PF(it));
621| 163| }
622| 19.8k| } else if (xmlStrEqual(*it, toXmlChar("for"))) {
------------------
| | 75| 19.8k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 19.8k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (622:20): [True: 16.5k, False: 3.33k]
------------------
623| | /* graph, vertex or edge attribute? */
624| 16.5k| if (xmlAttrValueEqual(it, "graph")) {
------------------
| Branch (624:17): [True: 1.99k, False: 14.5k]
------------------
625| 1.99k| trie = &state->g_attr_ids;
626| 1.99k| ptrvector = &state->g_attrs;
627| 14.5k| } else if (xmlAttrValueEqual(it, "node")) {
------------------
| Branch (627:24): [True: 7.65k, False: 6.87k]
------------------
628| 7.65k| trie = &state->v_attr_ids;
629| 7.65k| ptrvector = &state->v_attrs;
630| 7.65k| } else if (xmlAttrValueEqual(it, "edge")) {
------------------
| Branch (630:24): [True: 5.15k, False: 1.72k]
------------------
631| 5.15k| trie = &state->e_attr_ids;
632| 5.15k| ptrvector = &state->e_attrs;
633| 5.15k| } else if (xmlAttrValueEqual(it, "graphml")) {
------------------
| Branch (633:24): [True: 194, False: 1.52k]
------------------
634| 194| igraph_i_report_unhandled_attribute_target("graphml", IGRAPH_FILE_BASENAME, __LINE__);
635| 194| skip = 1;
636| 1.52k| } else if (xmlAttrValueEqual(it, "hyperedge")) {
------------------
| Branch (636:24): [True: 194, False: 1.33k]
------------------
637| 194| igraph_i_report_unhandled_attribute_target("hyperedge", IGRAPH_FILE_BASENAME, __LINE__);
638| 194| skip = 1;
639| 1.33k| } else if (xmlAttrValueEqual(it, "port")) {
------------------
| Branch (639:24): [True: 638, False: 696]
------------------
640| 638| igraph_i_report_unhandled_attribute_target("port", IGRAPH_FILE_BASENAME, __LINE__);
641| 638| skip = 1;
642| 696| } else if (xmlAttrValueEqual(it, "endpoint")) {
------------------
| Branch (642:24): [True: 194, False: 502]
------------------
643| 194| igraph_i_report_unhandled_attribute_target("endpoint", IGRAPH_FILE_BASENAME, __LINE__);
644| 194| skip = 1;
645| 502| } else if (xmlAttrValueEqual(it, "all")) {
------------------
| Branch (645:24): [True: 357, False: 145]
------------------
646| | /* TODO: we should handle this */
647| 357| igraph_i_report_unhandled_attribute_target("all", IGRAPH_FILE_BASENAME, __LINE__);
648| 357| skip = 1;
649| 357| } else {
650| 145| IGRAPH_ERRORF("Unknown value '%.*s' in the 'for' attribute of a tag.", IGRAPH_PARSEERROR,
------------------
| | 464| 145| do { \
| | 465| 145| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 145| igraph_errno, __VA_ARGS__) ; \
| | 467| 145| return igraph_errno; \
| | 468| 145| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
651| 145| XML_ATTR_VALUE_PF(it));
652| 145| }
653| 16.5k| }
654| 63.5k| }
655| |
656| | /* throw an error if there is no ID; this is a clear violation of the GraphML DTD */
657| 17.9k| if (rec->id == NULL) {
------------------
| Branch (657:9): [True: 81, False: 17.8k]
------------------
658| 81| IGRAPH_ERROR("Found tag with no 'id' attribute.", IGRAPH_PARSEERROR);
------------------
| | 426| 81| do { \
| | 427| 81| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 81| return igraph_errno ; \
| | 429| 81| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
659| 81| }
660| |
661| | /* throw an error if the ID is an empty string; this is also a clear violation of the GraphML DTD */
662| 17.8k| if (*(rec->id) == '\0') {
------------------
| Branch (662:9): [True: 45, False: 17.8k]
------------------
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| 17.8k| if (attr_name == NULL) {
------------------
| Branch (667:9): [True: 7.26k, False: 10.5k]
------------------
668| | /* Allocation here is protected by safely_free_optional_string(&attr_name),
669| | * which is already in the finally stack */
670| 7.26k| attr_name = strdup(rec->id);
671| 7.26k| IGRAPH_CHECK_OOM(attr_name, "Cannot duplicate attribute ID as name.");
------------------
| | 709| 7.26k| do { \
| | 710| 7.26k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 7.26k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.26k]
| | | | ------------------
| | ------------------
| | 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.26k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 7.26k]
| | ------------------
------------------
672| 7.26k| }
673| |
674| | /* if the attribute type is missing, ignore the attribute with a warning */
675| 17.8k| if (!skip && rec->type == I_GRAPHML_UNKNOWN_TYPE) {
------------------
| Branch (675:9): [True: 16.2k, False: 1.55k]
| Branch (675:18): [True: 0, False: 16.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| 17.8k| if (!skip && trie == 0) {
------------------
| Branch (681:9): [True: 16.2k, False: 1.55k]
| Branch (681:18): [True: 1.51k, False: 14.7k]
------------------
682| 1.51k| IGRAPH_WARNINGF("Ignoring because of a missing 'for' attribute.", rec->id);
------------------
| | 777| 1.51k| do { \
| | 778| 1.51k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 1.51k| __VA_ARGS__); \
| | 780| 1.51k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 1.51k]
| | ------------------
------------------
683| 1.51k| skip = 1;
684| 1.51k| }
685| |
686| | /* If attribute is skipped, proceed according to the type of the associated graph element. */
687| 17.8k| if (skip) {
------------------
| Branch (687:9): [True: 3.06k, False: 14.7k]
------------------
688| 3.06k| if (trie == 0) {
------------------
| Branch (688:13): [True: 3.06k, False: 0]
------------------
689| | /* Attribute was skipped because it is not for a node, edge or the graph.
690| | * Free everything and return. */
691| 3.06k| if (rec) {
------------------
| Branch (691:17): [True: 3.06k, False: 0]
------------------
692| 3.06k| igraph_i_graphml_attribute_record_destroy(rec);
693| 3.06k| IGRAPH_FREE(rec);
------------------
| | 36| 3.06k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
694| 3.06k| }
695| 3.06k| IGRAPH_FINALLY_CLEAN(2);
696| 3.06k| goto exit;
697| 3.06k| } 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| 3.06k| }
704| |
705| | /* check if we have already seen this ID */
706| 14.7k| IGRAPH_CHECK(igraph_trie_check(trie, rec->id, &id));
------------------
| | 656| 14.7k| do { \
| | 657| 14.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.7k]
| | ------------------
------------------
707| 14.7k| if (id >= 0) {
------------------
| Branch (707:9): [True: 5, False: 14.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| 14.7k| n = igraph_vector_ptr_size(ptrvector);
713| 31.6k| for (i = 0; i < n; i++) {
------------------
| Branch (713:17): [True: 16.8k, False: 14.7k]
------------------
714| 16.8k| if (!strcmp(
------------------
| Branch (714:13): [True: 1, False: 16.8k]
------------------
715| 16.8k| attr_name,
716| 16.8k| ((igraph_i_graphml_attribute_record_t*) igraph_vector_ptr_get(ptrvector, i))->record.name
717| 16.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| 16.8k| }
724| |
725| | /* add to trie, attributes */
726| 14.7k| IGRAPH_CHECK(igraph_trie_get(trie, rec->id, &id));
------------------
| | 656| 14.7k| do { \
| | 657| 14.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.7k]
| | ------------------
------------------
727| 14.7k| IGRAPH_CHECK(igraph_vector_ptr_push_back(ptrvector, rec));
------------------
| | 656| 14.7k| do { \
| | 657| 14.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.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| 14.7k| IGRAPH_FINALLY_CLEAN(2);
732| |
733| | /* create the attribute values */
734| 14.7k| IGRAPH_CHECK(igraph_attribute_record_init(&rec->record, attr_name, igraph_attr_type));
------------------
| | 656| 14.7k| do { \
| | 657| 14.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.7k]
| | ------------------
------------------
735| |
736| 17.7k|exit:
737| 17.7k| safely_free_optional_string(&attr_name);
738| 17.7k| IGRAPH_FINALLY_CLEAN(1);
739| |
740| 17.7k| *record = rec;
741| 17.7k| return IGRAPH_SUCCESS;
742| 14.7k|}
graphml.c:safely_free_optional_string:
525| 46.7k|static void safely_free_optional_string(char** str) {
526| 46.7k| if (*str != NULL) {
------------------
| Branch (526:9): [True: 17.8k, False: 28.8k]
------------------
527| 17.8k| igraph_free(*str);
528| | *str = NULL;
529| 17.8k| }
530| 46.7k|}
graphml.c:safely_convert_xml_attribute_to_string:
504| 28.4k|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| 28.4k| xmlChar *xml_str;
508| 28.4k| char *c_str;
509| |
510| 28.4k| xml_str = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 28.4k|#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| 28.4k| IGRAPH_CHECK_OOM(xml_str, "Insufficient memory to duplicate attribute value.");
------------------
| | 709| 28.4k| do { \
| | 710| 28.4k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 28.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.4k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 28.4k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 28.4k]
| | ------------------
------------------
512| 28.4k| IGRAPH_FINALLY(xmlFree, xml_str);
------------------
| | 603| 28.4k| do { \
| | 604| 28.4k| /* the following branch makes the compiler check the compatibility of \
| | 605| 28.4k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 28.4k| * incorrect destructor function with the pointer */ \
| | 607| 28.4k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 28.4k]
| | ------------------
| | 608| 28.4k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 28.4k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 28.4k]
| | ------------------
------------------
513| |
514| 28.4k| c_str = strdup(fromXmlChar(xml_str));
------------------
| | 76| 28.4k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
515| 28.4k| IGRAPH_CHECK_OOM(c_str, "Insufficient memory to duplicate attribute value.");
------------------
| | 709| 28.4k| do { \
| | 710| 28.4k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 28.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 28.4k]
| | | | ------------------
| | ------------------
| | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 712| 0| } \
| | 713| 28.4k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 28.4k]
| | ------------------
------------------
516| |
517| 28.4k| *str = c_str;
518| |
519| 28.4k| xmlFree(xml_str);
520| 28.4k| IGRAPH_FINALLY_CLEAN(1);
521| |
522| 28.4k| return IGRAPH_SUCCESS;
523| 28.4k|}
graphml.c:igraph_i_report_unhandled_attribute_target:
132| 1.57k| const char* file, int line) {
133| 1.57k| igraph_warningf("Attribute target '%s' is not handled; ignoring corresponding "
134| 1.57k| "attribute specifications.", file, line, target);
135| 1.57k|}
graphml.c:igraph_i_graphml_attribute_data_setup:
747| 370k|) {
748| 370k| xmlChar **it;
749| 370k| int i;
750| |
751| 370k| if (!state->successful) {
------------------
| Branch (751:9): [True: 0, False: 370k]
------------------
752| 0| return IGRAPH_SUCCESS;
753| 0| }
754| |
755| 739k| for (i = 0, it = (xmlChar**)attrs; i < nb_attrs; i++, it += 5) {
------------------
| Branch (755:40): [True: 369k, False: 370k]
------------------
756| 369k| if (XML_ATTR_URI(it) != 0 &&
------------------
| | 497| 369k|#define XML_ATTR_URI(it) it[2]
------------------
| Branch (756:13): [True: 20, False: 369k]
------------------
757| 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 (757:13): [True: 10, False: 10]
------------------
758| 10| continue;
759| 10| }
760| |
761| 369k| if (xmlStrEqual(*it, toXmlChar("key"))) {
------------------
| | 75| 369k|#define toXmlChar(a) (BAD_CAST(a))
| | ------------------
| | | | 34| 369k|#define BAD_CAST (xmlChar *)
| | ------------------
------------------
| Branch (761:13): [True: 368k, False: 665]
------------------
762| 368k| if (state->data_key) {
------------------
| Branch (762:17): [True: 364k, False: 3.70k]
------------------
763| 364k| xmlFree((void *) state->data_key);
764| 364k| state->data_key = NULL;
765| 364k| }
766| 368k| state->data_key = xmlStrndup(XML_ATTR_VALUE(it));
------------------
| | 501| 368k|#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| 368k| IGRAPH_CHECK_OOM(state->data_key, "Insufficient memory to read GraphML file.");
------------------
| | 709| 368k| do { \
| | 710| 368k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 368k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 368k]
| | | | ------------------
| | ------------------
| | 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| 368k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 368k]
| | ------------------
------------------
768| 368k| igraph_vector_char_clear(&state->data_char);
769| 368k| state->data_type = type;
770| 368k| } else {
771| | /* ignore */
772| 665| }
773| 369k| }
774| |
775| 370k| return IGRAPH_SUCCESS;
776| 370k|}
graphml.c:igraph_i_graphml_sax_handler_end_element_ns:
1280| 1.10M| const xmlChar* uri) {
1281| 1.10M| struct igraph_i_graphml_parser_state *state =
1282| 1.10M| (struct igraph_i_graphml_parser_state*)state0;
1283| 1.10M| igraph_error_t result;
1284| |
1285| 1.10M| if (!state->successful) {
------------------
| Branch (1285:9): [True: 7.18k, False: 1.09M]
------------------
1286| 7.18k| return;
1287| 7.18k| }
1288| |
1289| 1.09M| result = igraph_i_graphml_sax_handler_end_element_ns_inner(
1290| 1.09M| state, localname, prefix, uri
1291| 1.09M| );
1292| |
1293| 1.09M| if (result != IGRAPH_SUCCESS) {
------------------
| Branch (1293:9): [True: 122, False: 1.09M]
------------------
1294| 122| RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file.", result);
------------------
| | 85| 122| do { \
| | 86| 122| GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code); \
| | ------------------
| | | | 79| 122| do { \
| | | | 80| 122| if (state->successful) { \
| | | | ------------------
| | | | | Branch (80:13): [True: 122, False: 0]
| | | | ------------------
| | | | 81| 122| igraph_i_graphml_sax_handler_error(state, msg); \
| | | | 82| 122| } \
| | | | 83| 122| } while (0)
| | | | ------------------
| | | | | Branch (83:14): [Folded, False: 122]
| | | | ------------------
| | ------------------
| | 87| 122| return; \
| | 88| 122| } while (0)
| | ------------------
| | | Branch (88:14): [Folded, False: 0]
| | ------------------
------------------
1295| 122| }
1296| 1.09M|}
graphml.c:igraph_i_graphml_sax_handler_end_element_ns_inner:
1221| 1.09M|) {
1222| 1.09M| IGRAPH_UNUSED(localname);
------------------
| | 30| 1.09M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1223| 1.09M| IGRAPH_UNUSED(prefix);
------------------
| | 30| 1.09M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1224| 1.09M| IGRAPH_UNUSED(uri);
------------------
| | 30| 1.09M|#define IGRAPH_UNUSED(x) (void)(x)
------------------
1225| |
1226| 1.09M| switch (state->st) {
1227| 7.13k| case INSIDE_GRAPHML:
------------------
| Branch (1227:5): [True: 7.13k, False: 1.09M]
------------------
1228| 7.13k| state->st = FINISH;
1229| 7.13k| break;
1230| |
1231| 7.16k| case INSIDE_GRAPH:
------------------
| Branch (1231:5): [True: 7.16k, False: 1.08M]
------------------
1232| 7.16k| state->st = INSIDE_GRAPHML;
1233| 7.16k| break;
1234| |
1235| 17.4k| case INSIDE_KEY:
------------------
| Branch (1235:5): [True: 17.4k, False: 1.07M]
------------------
1236| 17.4k| state->current_attr_record = NULL;
1237| 17.4k| state->st = INSIDE_GRAPHML;
1238| 17.4k| break;
1239| |
1240| 4.03k| case INSIDE_DEFAULT:
------------------
| Branch (1240:5): [True: 4.03k, False: 1.09M]
------------------
1241| 4.03k| IGRAPH_CHECK(igraph_i_graphml_attribute_default_value_finish(state));
------------------
| | 656| 4.03k| do { \
| | 657| 4.03k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.03k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 90, False: 3.94k]
| | | | ------------------
| | ------------------
| | 659| 90| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 90| do { \
| | | | 427| 90| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 90| return igraph_errno ; \
| | | | 429| 90| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 90| } \
| | 661| 4.03k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.94k]
| | ------------------
------------------
1242| 3.94k| state->st = INSIDE_KEY;
1243| 3.94k| break;
1244| |
1245| 34.0k| case INSIDE_NODE:
------------------
| Branch (1245:5): [True: 34.0k, False: 1.06M]
------------------
1246| 34.0k| state->st = INSIDE_GRAPH;
1247| 34.0k| break;
1248| |
1249| 570k| case INSIDE_EDGE:
------------------
| Branch (1249:5): [True: 570k, False: 526k]
------------------
1250| 570k| state->st = INSIDE_GRAPH;
1251| 570k| break;
1252| |
1253| 370k| case INSIDE_DATA:
------------------
| Branch (1253:5): [True: 370k, False: 726k]
------------------
1254| 370k| IGRAPH_CHECK(igraph_i_graphml_attribute_data_finish(state));
------------------
| | 656| 370k| do { \
| | 657| 370k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 32, False: 370k]
| | | | ------------------
| | ------------------
| | 659| 32| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 32| do { \
| | | | 427| 32| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 32| return igraph_errno ; \
| | | | 429| 32| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 32| } \
| | 661| 370k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 370k]
| | ------------------
------------------
1255| 370k| IGRAPH_ASSERT(!igraph_vector_int_empty(&state->prev_state_stack));
------------------
| | 924| 370k| do { \
| | 925| 370k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 370k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 370k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 370k]
| | ------------------
------------------
1256| 370k| state->st = (igraph_i_graphml_parser_state_index_t) igraph_vector_int_pop_back(&state->prev_state_stack);
1257| 370k| break;
1258| |
1259| 84.8k| case UNKNOWN:
------------------
| Branch (1259:5): [True: 84.8k, False: 1.01M]
------------------
1260| 84.8k| state->unknown_depth--;
1261| 84.8k| if (!state->unknown_depth) {
------------------
| Branch (1261:13): [True: 8.04k, False: 76.8k]
------------------
1262| 8.04k| IGRAPH_ASSERT(!igraph_vector_int_empty(&state->prev_state_stack));
------------------
| | 924| 8.04k| do { \
| | 925| 8.04k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 8.04k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 8.04k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 8.04k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 8.04k]
| | ------------------
------------------
1263| 8.04k| state->st = (igraph_i_graphml_parser_state_index_t) igraph_vector_int_pop_back(&state->prev_state_stack);
1264| 8.04k| }
1265| 84.8k| break;
1266| |
1267| 84.8k| case FINISH:
------------------
| Branch (1267:5): [True: 1.27k, False: 1.09M]
------------------
1268| 1.27k| break;
1269| |
1270| 0| default:
------------------
| Branch (1270:5): [True: 0, False: 1.09M]
------------------
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.09M| }
1273| |
1274| 1.09M| return IGRAPH_SUCCESS;
1275| 1.09M|}
graphml.c:igraph_i_graphml_attribute_default_value_finish:
899| 4.03k|static igraph_error_t igraph_i_graphml_attribute_default_value_finish(struct igraph_i_graphml_parser_state *state) {
900| 4.03k| igraph_i_graphml_attribute_record_t *graphmlrec = state->current_attr_record;
901| 4.03k| igraph_attribute_record_t *rec;
902| 4.03k| igraph_error_t result = IGRAPH_SUCCESS;
903| 4.03k| igraph_real_t default_num;
904| 4.03k| igraph_bool_t default_bool;
905| |
906| 4.03k| IGRAPH_ASSERT(state->current_attr_record != NULL);
------------------
| | 924| 4.03k| do { \
| | 925| 4.03k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 4.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.03k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 4.03k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 4.03k]
| | ------------------
------------------
907| |
908| 4.03k| if (igraph_vector_char_size(&state->data_char) == 0) {
------------------
| Branch (908:9): [True: 341, False: 3.69k]
------------------
909| 341| return IGRAPH_SUCCESS;
910| 341| }
911| |
912| 3.69k| rec = &graphmlrec->record;
913| |
914| 3.69k| switch (rec->type) {
915| 1.82k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (915:5): [True: 1.82k, False: 1.87k]
------------------
916| | /* Add null terminator */
917| 1.82k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 1.82k| do { \
| | 657| 1.82k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.82k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.82k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.82k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.82k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.82k]
| | ------------------
------------------
918| 1.82k| IGRAPH_CHECK(igraph_i_graphml_parse_boolean(VECTOR(state->data_char), &default_bool, false));
------------------
| | 656| 1.82k| do { \
| | 657| 1.82k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.82k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.82k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 88, False: 1.73k]
| | | | ------------------
| | ------------------
| | 659| 88| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 88| do { \
| | | | 427| 88| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 88| return igraph_errno ; \
| | | | 429| 88| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 88| } \
| | 661| 1.82k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.73k]
| | ------------------
------------------
919| 1.73k| IGRAPH_CHECK(igraph_attribute_record_set_default_boolean(rec, default_bool));
------------------
| | 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: 0, False: 1.73k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.73k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.73k]
| | ------------------
------------------
920| 1.73k| break;
921| 1.73k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (921:5): [True: 606, False: 3.09k]
------------------
922| | /* Add null terminator */
923| 606| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 606| do { \
| | 657| 606| igraph_error_t igraph_i_ret = (expr); \
| | 658| 606| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 606| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 606]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 606| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 606]
| | ------------------
------------------
924| 606| IGRAPH_CHECK(igraph_i_graphml_parse_numeric(VECTOR(state->data_char), &default_num, IGRAPH_NAN));
------------------
| | 656| 606| do { \
| | 657| 606| igraph_error_t igraph_i_ret = (expr); \
| | 658| 606| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 606| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 2, False: 604]
| | | | ------------------
| | ------------------
| | 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| 606| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 604]
| | ------------------
------------------
925| 604| IGRAPH_CHECK(igraph_attribute_record_set_default_numeric(rec, default_num));
------------------
| | 656| 604| do { \
| | 657| 604| igraph_error_t igraph_i_ret = (expr); \
| | 658| 604| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 604| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 604]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 604| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 604]
| | ------------------
------------------
926| 604| break;
927| 1.02k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (927:5): [True: 1.02k, False: 2.66k]
------------------
928| | /* Add null terminator */
929| 1.02k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 1.02k| do { \
| | 657| 1.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.02k]
| | ------------------
------------------
930| 1.02k| IGRAPH_CHECK(igraph_attribute_record_set_default_string(rec, VECTOR(state->data_char)));
------------------
| | 656| 1.02k| do { \
| | 657| 1.02k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.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| 1.02k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.02k]
| | ------------------
------------------
931| 1.02k| break;
932| 1.02k| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (932:5): [True: 240, False: 3.45k]
------------------
933| 240| break;
934| 0| default:
------------------
| Branch (934:5): [True: 0, False: 3.69k]
------------------
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.69k| }
937| |
938| 3.60k| igraph_vector_char_clear(&state->data_char);
939| |
940| 3.60k| return result;
941| 3.69k|}
graphml.c:igraph_i_graphml_parse_boolean:
160| 12.3k|) {
161| 12.3k| igraph_int_t value;
162| 12.3k| const char* trimmed;
163| 12.3k| size_t trimmed_length;
164| |
165| 12.3k| if (char_data == 0) {
------------------
| Branch (165:9): [True: 0, False: 12.3k]
------------------
166| 0| *result = default_value;
167| 0| return IGRAPH_SUCCESS;
168| 0| }
169| |
170| 12.3k| igraph_i_trim_whitespace(char_data, strlen(char_data), &trimmed, &trimmed_length);
171| |
172| 12.3k| if (trimmed_length == 4 && !strncasecmp(trimmed, "true", trimmed_length)) {
------------------
| Branch (172:9): [True: 560, False: 11.8k]
| Branch (172:32): [True: 227, False: 333]
------------------
173| 227| *result = 1;
174| 227| return IGRAPH_SUCCESS;
175| 227| }
176| |
177| 12.1k| if (trimmed_length == 3 && !strncasecmp(trimmed, "yes", trimmed_length)) {
------------------
| Branch (177:9): [True: 283, False: 11.8k]
| Branch (177:32): [True: 66, False: 217]
------------------
178| 66| *result = 1;
179| 66| return IGRAPH_SUCCESS;
180| 66| }
181| |
182| 12.0k| if (trimmed_length == 5 && !strncasecmp(trimmed, "false", trimmed_length)) {
------------------
| Branch (182:9): [True: 10.7k, False: 1.35k]
| Branch (182:32): [True: 10.5k, False: 226]
------------------
183| 10.5k| *result = 0;
184| 10.5k| return IGRAPH_SUCCESS;
185| 10.5k| }
186| |
187| 1.57k| if (trimmed_length == 2 && !strncasecmp(trimmed, "no", trimmed_length)) {
------------------
| Branch (187:9): [True: 450, False: 1.12k]
| Branch (187:32): [True: 238, False: 212]
------------------
188| 238| *result = 0;
189| 238| return IGRAPH_SUCCESS;
190| 238| }
191| |
192| 1.34k| if (trimmed_length > 0) {
------------------
| Branch (192:9): [True: 1.11k, False: 222]
------------------
193| 1.11k| if (isdigit(trimmed[0])) {
------------------
| Branch (193:13): [True: 1.03k, False: 81]
------------------
194| 1.03k| IGRAPH_CHECK(igraph_i_parse_integer(trimmed, trimmed_length, &value));
------------------
| | 656| 1.03k| do { \
| | 657| 1.03k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.03k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 23, False: 1.01k]
| | | | ------------------
| | ------------------
| | 659| 23| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 23| do { \
| | | | 427| 23| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 23| return igraph_errno ; \
| | | | 429| 23| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 23| } \
| | 661| 1.03k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.01k]
| | ------------------
------------------
195| 1.03k| } else {
196| 81| IGRAPH_ERRORF("Cannot parse '%.*s' as Boolean value.", 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]
| | ------------------
------------------
197| 81| (int) trimmed_length, trimmed);
198| 81| }
199| 1.11k| } else {
200| 222| *result = default_value;
201| 222| return IGRAPH_SUCCESS;
202| 222| }
203| |
204| 1.01k| *result = value != 0;
205| 1.01k| return IGRAPH_SUCCESS;
206| 1.34k|}
graphml.c:igraph_i_graphml_parse_numeric:
139| 6.51k|) {
140| 6.51k| const char* trimmed;
141| 6.51k| size_t trimmed_length;
142| |
143| 6.51k| if (char_data == 0) {
------------------
| Branch (143:9): [True: 0, False: 6.51k]
------------------
144| 0| *result = default_value;
145| 0| return IGRAPH_SUCCESS;
146| 0| }
147| |
148| 6.51k| igraph_i_trim_whitespace(char_data, strlen(char_data), &trimmed, &trimmed_length);
149| 6.51k| if (trimmed_length > 0) {
------------------
| Branch (149:9): [True: 6.09k, False: 421]
------------------
150| 6.09k| IGRAPH_CHECK(igraph_i_parse_real(trimmed, trimmed_length, result));
------------------
| | 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: 18, False: 6.07k]
| | | | ------------------
| | ------------------
| | 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.09k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 6.07k]
| | ------------------
------------------
151| 6.09k| } else {
152| 421| *result = default_value;
153| 421| }
154| |
155| 6.49k| return IGRAPH_SUCCESS;
156| 6.51k|}
graphml.c:igraph_i_graphml_attribute_data_finish:
797| 370k|static igraph_error_t igraph_i_graphml_attribute_data_finish(struct igraph_i_graphml_parser_state *state) {
798| 370k| const char *key = fromXmlChar(state->data_key);
------------------
| | 76| 370k|#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */
------------------
799| 370k| igraph_attribute_elemtype_t type = state->data_type;
800| 370k| igraph_trie_t *trie = NULL;
801| 370k| igraph_vector_ptr_t *ptrvector = NULL;
802| 370k| igraph_i_graphml_attribute_record_t *graphmlrec;
803| 370k| igraph_attribute_record_t *rec;
804| 370k| igraph_int_t recid, id = 0;
805| 370k| igraph_error_t result = IGRAPH_SUCCESS;
806| |
807| 370k| switch (type) {
808| 3.27k| case IGRAPH_ATTRIBUTE_GRAPH:
------------------
| Branch (808:5): [True: 3.27k, False: 367k]
------------------
809| 3.27k| trie = &state->g_attr_ids;
810| 3.27k| ptrvector = &state->g_attrs;
811| 3.27k| id = 0;
812| 3.27k| break;
813| 51.1k| case IGRAPH_ATTRIBUTE_VERTEX:
------------------
| Branch (813:5): [True: 51.1k, False: 319k]
------------------
814| 51.1k| trie = &state->v_attr_ids;
815| 51.1k| ptrvector = &state->v_attrs;
816| 51.1k| id = state->act_node;
817| 51.1k| break;
818| 315k| case IGRAPH_ATTRIBUTE_EDGE:
------------------
| Branch (818:5): [True: 315k, False: 54.4k]
------------------
819| 315k| trie = &state->e_attr_ids;
820| 315k| ptrvector = &state->e_attrs;
821| 315k| id = igraph_vector_int_size(&state->edgelist) / 2 - 1; /* hack */
822| 315k| break;
823| 0| default:
------------------
| Branch (823:5): [True: 0, False: 370k]
------------------
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| 370k| }
826| |
827| 370k| if (key == 0) {
------------------
| Branch (827:9): [True: 334, False: 370k]
------------------
828| | /* no key specified, issue a warning */
829| 334| IGRAPH_WARNING("Missing attribute key in a tag, ignoring attribute.");
------------------
| | 797| 334| do { \
| | 798| 334| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 334| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 334]
| | ------------------
------------------
830| 334| goto exit;
831| 334| }
832| |
833| 370k| IGRAPH_CHECK(igraph_trie_check(trie, key, &recid));
------------------
| | 656| 370k| do { \
| | 657| 370k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 370k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 370k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 370k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 370k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 370k]
| | ------------------
------------------
834| 370k| if (recid < 0) {
------------------
| Branch (834:9): [True: 1.48k, False: 368k]
------------------
835| | /* no such attribute key, issue a warning */
836| 1.48k| IGRAPH_WARNINGF(
------------------
| | 777| 1.48k| do { \
| | 778| 1.48k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 1.48k| __VA_ARGS__); \
| | 780| 1.48k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 1.48k]
| | ------------------
------------------
837| 1.48k| "Unknown attribute key '%s' in a tag, ignoring attribute.",
838| 1.48k| key
839| 1.48k| );
840| 1.48k| goto exit;
841| 1.48k| }
842| |
843| 368k| graphmlrec = VECTOR(*ptrvector)[recid];
------------------
| | 60| 368k|#define VECTOR(v) ((v).stor_begin)
------------------
844| 368k| rec = &graphmlrec->record;
845| |
846| 368k| if (id >= igraph_attribute_record_size(rec) && rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (846:9): [True: 367k, False: 707]
| Branch (846:52): [True: 367k, False: 342]
------------------
847| 367k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, id + 1));
------------------
| | 656| 367k| do { \
| | 657| 367k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 367k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 367k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 367k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 367k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 367k]
| | ------------------
------------------
848| 367k| }
849| |
850| 368k| 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.5k| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (856:5): [True: 10.5k, False: 358k]
------------------
857| | /* Add null terminator */
858| 10.5k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 10.5k| do { \
| | 657| 10.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 10.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| 10.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.5k]
| | ------------------
------------------
859| 10.5k| boolvec = rec->value.as_vector_bool;
860| 10.5k| IGRAPH_CHECK(igraph_i_graphml_parse_boolean(
------------------
| | 656| 10.5k| do { \
| | 657| 10.5k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 10.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 10.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 16, False: 10.5k]
| | | | ------------------
| | ------------------
| | 659| 16| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 16| do { \
| | | | 427| 16| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 16| return igraph_errno ; \
| | | | 429| 16| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 16| } \
| | 661| 10.5k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 10.5k]
| | ------------------
------------------
861| 10.5k| VECTOR(state->data_char), VECTOR(*boolvec) + id, rec->default_value.boolean
862| 10.5k| ));
863| 10.5k| break;
864| |
865| 10.5k| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (865:5): [True: 5.90k, False: 362k]
------------------
866| | /* Add null terminator */
867| 5.90k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 5.90k| do { \
| | 657| 5.90k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.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| 5.90k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.90k]
| | ------------------
------------------
868| 5.90k| vec = rec->value.as_vector;
869| 5.90k| IGRAPH_CHECK(igraph_i_graphml_parse_numeric(
------------------
| | 656| 5.90k| do { \
| | 657| 5.90k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 16, False: 5.89k]
| | | | ------------------
| | ------------------
| | 659| 16| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 16| do { \
| | | | 427| 16| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 16| return igraph_errno ; \
| | | | 429| 16| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 16| } \
| | 661| 5.90k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.89k]
| | ------------------
------------------
870| 5.90k| VECTOR(state->data_char), VECTOR(*vec) + id, rec->default_value.numeric
871| 5.90k| ));
872| 5.89k| break;
873| |
874| 351k| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (874:5): [True: 351k, False: 16.8k]
------------------
875| | /* Ensure that the vector ends with a null terminator */
876| 351k| strvec = rec->value.as_strvector;
877| 351k| if (igraph_vector_char_size(&state->data_char) > 0) {
------------------
| Branch (877:13): [True: 238k, False: 113k]
------------------
878| 238k| IGRAPH_CHECK(igraph_vector_char_push_back(&state->data_char, '\x00'));
------------------
| | 656| 238k| do { \
| | 657| 238k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 238k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 238k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 238k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 238k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 238k]
| | ------------------
------------------
879| 238k| strvalue = VECTOR(state->data_char);
------------------
| | 60| 238k|#define VECTOR(v) ((v).stor_begin)
------------------
880| 238k| } else {
881| 113k| strvalue = rec->default_value.string;
882| 113k| }
883| 351k| IGRAPH_CHECK(igraph_strvector_set(strvec, id, strvalue ? strvalue : ""));
------------------
| | 656| 351k| do { \
| | 657| 703k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 238k, False: 113k]
| | ------------------
| | 658| 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]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 351k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 351k]
| | ------------------
------------------
884| 351k| break;
885| |
886| 351k| case IGRAPH_ATTRIBUTE_UNSPECIFIED:
------------------
| Branch (886:5): [True: 342, False: 368k]
------------------
887| 342| break;
888| |
889| 0| default:
------------------
| Branch (889:5): [True: 0, False: 368k]
------------------
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| 368k| }
892| |
893| 370k|exit:
894| 370k| igraph_vector_char_clear(&state->data_char);
895| |
896| 370k| return result;
897| 368k|}
graphml.c:igraph_i_graphml_parser_state_finish_parsing:
389| 7.11k|static igraph_error_t igraph_i_graphml_parser_state_finish_parsing(struct igraph_i_graphml_parser_state *state) {
390| 7.11k| igraph_int_t i;
391| 7.11k| const char *idstr = "id";
392| 7.11k| igraph_bool_t already_has_vertex_id = false, already_has_edge_id = false;
393| 7.11k| igraph_attribute_record_list_t vattr, eattr, gattr;
394| 7.11k| igraph_attribute_record_t *idrec;
395| |
396| 7.11k| IGRAPH_ASSERT(state->successful);
------------------
| | 924| 7.11k| do { \
| | 925| 7.11k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.11k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 7.11k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 7.11k]
| | ------------------
------------------
397| |
398| | /* check that we have found and parsed the graph the user is interested in */
399| 7.11k| IGRAPH_ASSERT(state->index < 0);
------------------
| | 924| 7.11k| do { \
| | 925| 7.11k| if (IGRAPH_UNLIKELY(!(condition))) { \
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.11k]
| | | | ------------------
| | ------------------
| | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
| | 927| 0| } \
| | 928| 7.11k| } while (0)
| | ------------------
| | | Branch (928:14): [Folded, False: 7.11k]
| | ------------------
------------------
400| |
401| 7.11k| IGRAPH_CHECK(igraph_attribute_record_list_init(&vattr, 0));
------------------
| | 656| 7.11k| do { \
| | 657| 7.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.11k]
| | ------------------
------------------
402| 7.11k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &vattr);
------------------
| | 603| 7.11k| do { \
| | 604| 7.11k| /* the following branch makes the compiler check the compatibility of \
| | 605| 7.11k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 7.11k| * incorrect destructor function with the pointer */ \
| | 607| 7.11k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 7.11k]
| | ------------------
| | 608| 7.11k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 7.11k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 7.11k]
| | ------------------
------------------
403| 7.11k| IGRAPH_CHECK(igraph_attribute_record_list_init(&eattr, 0));
------------------
| | 656| 7.11k| do { \
| | 657| 7.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.11k]
| | ------------------
------------------
404| 7.11k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &eattr);
------------------
| | 603| 7.11k| do { \
| | 604| 7.11k| /* the following branch makes the compiler check the compatibility of \
| | 605| 7.11k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 7.11k| * incorrect destructor function with the pointer */ \
| | 607| 7.11k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 7.11k]
| | ------------------
| | 608| 7.11k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 7.11k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 7.11k]
| | ------------------
------------------
405| 7.11k| IGRAPH_CHECK(igraph_attribute_record_list_init(&gattr, 0));
------------------
| | 656| 7.11k| do { \
| | 657| 7.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.11k]
| | ------------------
------------------
406| 7.11k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &gattr);
------------------
| | 603| 7.11k| do { \
| | 604| 7.11k| /* the following branch makes the compiler check the compatibility of \
| | 605| 7.11k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 7.11k| * incorrect destructor function with the pointer */ \
| | 607| 7.11k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 7.11k]
| | ------------------
| | 608| 7.11k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 7.11k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 7.11k]
| | ------------------
------------------
407| |
408| | /* Add default attribute values for vertices where needed */
409| 14.3k| for (i = 0; i < igraph_vector_ptr_size(&state->v_attrs); i++) {
------------------
| Branch (409:17): [True: 7.26k, False: 7.11k]
------------------
410| 7.26k| igraph_i_graphml_attribute_record_t *graphmlrec =
411| 7.26k| VECTOR(state->v_attrs)[i];
------------------
| | 60| 7.26k|#define VECTOR(v) ((v).stor_begin)
------------------
412| 7.26k| 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| 7.26k| if (!strcmp(rec->name, idstr)) {
------------------
| Branch (416:13): [True: 3.58k, False: 3.67k]
------------------
417| 3.58k| already_has_vertex_id = 1;
418| 3.58k| }
419| |
420| 7.26k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (420:13): [True: 7.21k, False: 47]
------------------
421| 7.21k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, igraph_trie_size(&state->node_trie)));
------------------
| | 656| 7.21k| do { \
| | 657| 7.21k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.21k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.21k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.21k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.21k]
| | ------------------
------------------
422| 7.21k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&vattr, rec));
------------------
| | 656| 7.21k| do { \
| | 657| 7.21k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.21k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.21k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.21k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.21k]
| | ------------------
------------------
423| 7.21k| graphmlrec->record_disowned = true;
424| 7.21k| }
425| 7.26k| }
426| |
427| | /* Add vertex ID attribute if needed */
428| 7.11k| if (!already_has_vertex_id) {
------------------
| Branch (428:9): [True: 3.53k, False: 3.58k]
------------------
429| 3.53k| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(&vattr, &idrec));
------------------
| | 656| 3.53k| do { \
| | 657| 3.53k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.53k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.53k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.53k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.53k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.53k]
| | ------------------
------------------
430| 3.53k| IGRAPH_CHECK(igraph_attribute_record_set_name(idrec, idstr));
------------------
| | 656| 3.53k| do { \
| | 657| 3.53k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.53k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.53k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.53k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.53k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.53k]
| | ------------------
------------------
431| 3.53k| IGRAPH_CHECK(igraph_attribute_record_set_type(idrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.53k| do { \
| | 657| 3.53k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.53k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.53k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.53k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.53k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.53k]
| | ------------------
------------------
432| 3.53k| IGRAPH_CHECK(igraph_strvector_update(idrec->value.as_strvector, igraph_i_trie_borrow_keys(&state->node_trie)));
------------------
| | 656| 3.53k| do { \
| | 657| 3.53k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.53k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.53k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.53k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 3.53k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.53k]
| | ------------------
------------------
433| 3.58k| } else {
434| 3.58k| IGRAPH_WARNING("Could not add vertex ids, there is already an 'id' vertex attribute.");
------------------
| | 797| 3.58k| do { \
| | 798| 3.58k| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \
| | 799| 3.58k| } while (0)
| | ------------------
| | | Branch (799:14): [Folded, False: 3.58k]
| | ------------------
------------------
435| 3.58k| }
436| |
437| | /* Add default attribute values for edges where needed */
438| 12.0k| for (i = 0; i < igraph_vector_ptr_size(&state->e_attrs); i++) {
------------------
| Branch (438:17): [True: 4.88k, False: 7.11k]
------------------
439| 4.88k| igraph_i_graphml_attribute_record_t *graphmlrec =
440| 4.88k| VECTOR(state->e_attrs)[i];
------------------
| | 60| 4.88k|#define VECTOR(v) ((v).stor_begin)
------------------
441| 4.88k| igraph_attribute_record_t *rec = &graphmlrec->record;
442| |
443| 4.88k| if (!strcmp(rec->name, idstr)) {
------------------
| Branch (443:13): [True: 913, False: 3.97k]
------------------
444| 913| already_has_edge_id = 1;
445| 913| }
446| |
447| 4.88k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (447:13): [True: 4.70k, False: 179]
------------------
448| 4.70k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, igraph_vector_int_size(&state->edgelist) / 2));
------------------
| | 656| 4.70k| do { \
| | 657| 4.70k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.70k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.70k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.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| 4.70k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.70k]
| | ------------------
------------------
449| 4.70k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&eattr, rec));
------------------
| | 656| 4.70k| do { \
| | 657| 4.70k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 4.70k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 4.70k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 4.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| 4.70k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 4.70k]
| | ------------------
------------------
450| 4.70k| graphmlrec->record_disowned = true;
451| 4.70k| }
452| 4.88k| }
453| |
454| | /* Add edge ID attribute if needed */
455| 7.11k| if (igraph_strvector_size(&state->edgeids) != 0) {
------------------
| Branch (455:9): [True: 914, False: 6.20k]
------------------
456| 914| if (!already_has_edge_id) {
------------------
| Branch (456:13): [True: 913, False: 1]
------------------
457| 913| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(&eattr, &idrec));
------------------
| | 656| 913| do { \
| | 657| 913| igraph_error_t igraph_i_ret = (expr); \
| | 658| 913| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 913| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 913]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 913| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 913]
| | ------------------
------------------
458| 913| IGRAPH_CHECK(igraph_attribute_record_set_name(idrec, idstr));
------------------
| | 656| 913| do { \
| | 657| 913| igraph_error_t igraph_i_ret = (expr); \
| | 658| 913| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 913| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 913]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 913| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 913]
| | ------------------
------------------
459| 913| IGRAPH_CHECK(igraph_attribute_record_set_type(idrec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 913| do { \
| | 657| 913| igraph_error_t igraph_i_ret = (expr); \
| | 658| 913| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 913| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 913]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 913| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 913]
| | ------------------
------------------
460| 913| IGRAPH_CHECK(igraph_strvector_update(idrec->value.as_strvector, &state->edgeids));
------------------
| | 656| 913| do { \
| | 657| 913| igraph_error_t igraph_i_ret = (expr); \
| | 658| 913| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 913| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 913]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 913| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 913]
| | ------------------
------------------
461| 913| IGRAPH_CHECK(igraph_attribute_record_resize(idrec, igraph_vector_int_size(&state->edgelist) / 2));
------------------
| | 656| 913| do { \
| | 657| 913| igraph_error_t igraph_i_ret = (expr); \
| | 658| 913| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 913| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 913]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 913| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 913]
| | ------------------
------------------
462| 913| } 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| 914| }
466| |
467| | /* Add default graph attribute values where needed */
468| 8.86k| for (i = 0; i < igraph_vector_ptr_size(&state->g_attrs); i++) {
------------------
| Branch (468:17): [True: 1.74k, False: 7.11k]
------------------
469| 1.74k| igraph_i_graphml_attribute_record_t *graphmlrec =
470| 1.74k| VECTOR(state->g_attrs)[i];
------------------
| | 60| 1.74k|#define VECTOR(v) ((v).stor_begin)
------------------
471| 1.74k| igraph_attribute_record_t *rec = &graphmlrec->record;
472| |
473| 1.74k| if (rec->type != IGRAPH_ATTRIBUTE_UNSPECIFIED) {
------------------
| Branch (473:13): [True: 1.69k, False: 51]
------------------
474| 1.69k| IGRAPH_CHECK(igraph_attribute_record_resize(rec, 1));
------------------
| | 656| 1.69k| do { \
| | 657| 1.69k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.69k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.69k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.69k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.69k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.69k]
| | ------------------
------------------
475| 1.69k| IGRAPH_CHECK(igraph_attribute_record_list_push_back(&gattr, rec));
------------------
| | 656| 1.69k| do { \
| | 657| 1.69k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 1.69k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 1.69k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 1.69k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.69k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.69k]
| | ------------------
------------------
476| 1.69k| graphmlrec->record_disowned = true;
477| 1.69k| }
478| 1.74k| }
479| |
480| 7.11k| IGRAPH_CHECK(igraph_empty_attrs(state->g, 0, state->edges_directed, &gattr));
------------------
| | 656| 7.11k| do { \
| | 657| 7.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.11k]
| | ------------------
------------------
481| 7.11k| IGRAPH_FINALLY(igraph_destroy, state->g); /* because the next two lines may fail as well */
------------------
| | 603| 7.11k| do { \
| | 604| 7.11k| /* the following branch makes the compiler check the compatibility of \
| | 605| 7.11k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 7.11k| * incorrect destructor function with the pointer */ \
| | 607| 7.11k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 7.11k]
| | ------------------
| | 608| 7.11k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 7.11k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 7.11k]
| | ------------------
------------------
482| 7.11k| IGRAPH_CHECK(igraph_add_vertices(state->g, igraph_trie_size(&state->node_trie), &vattr));
------------------
| | 656| 7.11k| do { \
| | 657| 7.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.11k]
| | ------------------
------------------
483| 7.11k| IGRAPH_CHECK(igraph_add_edges(state->g, &state->edgelist, &eattr));
------------------
| | 656| 7.11k| do { \
| | 657| 7.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 7.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 7.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 7.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| 7.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 7.11k]
| | ------------------
------------------
484| 7.11k| IGRAPH_FINALLY_CLEAN(1); /* graph construction completed successfully */
485| |
486| 7.11k| igraph_attribute_record_list_destroy(&vattr);
487| 7.11k| igraph_attribute_record_list_destroy(&eattr);
488| 7.11k| igraph_attribute_record_list_destroy(&gattr);
489| 7.11k| IGRAPH_FINALLY_CLEAN(3);
490| |
491| 7.11k| return IGRAPH_SUCCESS;
492| 7.11k|}
graphml.c:igraph_i_xml_escape:
1371| 728k|static igraph_error_t igraph_i_xml_escape(const char *src, char **dest, const char *what) {
1372| 728k| igraph_int_t destlen = 0;
1373| 728k| const char *s;
1374| 728k| char *d;
1375| 728k| unsigned char ch;
1376| |
1377| 286M| for (s = src; *s; s++, destlen++) {
------------------
| Branch (1377:19): [True: 286M, False: 728k]
------------------
1378| 286M| ch = (unsigned char)(*s);
1379| 286M| if (ch == '&') {
------------------
| Branch (1379:13): [True: 1.73k, False: 286M]
------------------
1380| 1.73k| destlen += 4;
1381| 286M| } else if (ch == '<') {
------------------
| Branch (1381:20): [True: 91.8k, False: 285M]
------------------
1382| 91.8k| destlen += 3;
1383| 285M| } else if (ch == '>') {
------------------
| Branch (1383:20): [True: 35.6M, False: 250M]
------------------
1384| 35.6M| destlen += 3;
1385| 250M| } else if (ch == '"') {
------------------
| Branch (1385:20): [True: 15.5M, False: 234M]
------------------
1386| 15.5M| destlen += 5;
1387| 234M| } else if (ch == '\'') {
------------------
| Branch (1387:20): [True: 146M, False: 88.7M]
------------------
1388| 146M| destlen += 5;
1389| 146M| } else if (IS_FORBIDDEN_CONTROL_CHAR(ch)) {
------------------
| | 1363| 88.7M|#define IS_FORBIDDEN_CONTROL_CHAR(x) ((x) < ' ' && (x) != '\t' && (x) != '\r' && (x) != '\n')
| | ------------------
| | | Branch (1363:39): [True: 11.3M, False: 77.4M]
| | | Branch (1363:52): [True: 11.2M, False: 84.9k]
| | | Branch (1363:67): [True: 11.2M, False: 419]
| | | Branch (1363:82): [True: 0, False: 11.2M]
| | ------------------
------------------
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| 286M| }
1394| 728k| *dest = IGRAPH_CALLOC(destlen + 1, char);
------------------
| | 33| 728k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.45M| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 728k, False: 0]
| | | | | Branch (31:24): [True: 728k, False: 0]
| | | | | Branch (31:66): [True: 728k, False: 0]
| | | | ------------------
| | ------------------
------------------
1395| 728k| IGRAPH_CHECK_OOM(dest, "Insufficient memory to write GraphML file.");
------------------
| | 709| 728k| do { \
| | 710| 728k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 728k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 728k]
| | | | ------------------
| | ------------------
| | 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| 728k| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 728k]
| | ------------------
------------------
1396| 286M| for (s = src, d = *dest; *s; s++, d++) {
------------------
| Branch (1396:30): [True: 286M, False: 728k]
------------------
1397| 286M| ch = (unsigned char)(*s);
1398| 286M| switch (ch) {
1399| 1.73k| case '&':
------------------
| Branch (1399:9): [True: 1.73k, False: 286M]
------------------
1400| 1.73k| strcpy(d, "&"); d += 4; break;
1401| 91.8k| case '<':
------------------
| Branch (1401:9): [True: 91.8k, False: 285M]
------------------
1402| 91.8k| strcpy(d, "<"); d += 3; break;
1403| 35.6M| case '>':
------------------
| Branch (1403:9): [True: 35.6M, False: 250M]
------------------
1404| 35.6M| strcpy(d, ">"); d += 3; break;
1405| 15.5M| case '"':
------------------
| Branch (1405:9): [True: 15.5M, False: 270M]
------------------
1406| 15.5M| strcpy(d, """); d += 5; break;
1407| 146M| case '\'':
------------------
| Branch (1407:9): [True: 146M, False: 139M]
------------------
1408| 146M| strcpy(d, "'"); d += 5; break;
1409| 88.7M| default:
------------------
| Branch (1409:9): [True: 88.7M, False: 197M]
------------------
1410| 88.7M| *d = ch;
1411| 286M| }
1412| 286M| }
1413| 728k| *d = 0;
1414| 728k| return IGRAPH_SUCCESS;
1415| 728k|}
igraph_write_graph_leda:
66| 3.57k| const char *edge_attr_name) {
67| 3.57k| igraph_int_t no_of_nodes = igraph_vcount(graph);
68| 3.57k| igraph_int_t no_of_edges = igraph_ecount(graph);
69| 3.57k| igraph_eit_t it;
70| 3.57k| igraph_int_t i = 0;
71| 3.57k| igraph_attribute_type_t vertex_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
72| 3.57k| igraph_attribute_type_t edge_attr_type = IGRAPH_ATTRIBUTE_UNSPECIFIED;
73| 3.57k| igraph_int_t from, to, rev;
74| |
75| 3.57k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM), &it));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
76| 3.57k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
77| |
78| | /* Check if we have the vertex attribute */
79| 3.57k| if (vertex_attr_name &&
------------------
| Branch (79:9): [True: 3.57k, False: 0]
------------------
80| 3.57k| !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vertex_attr_name)) {
------------------
| Branch (80:9): [True: 3.11k, False: 461]
------------------
81| 3.11k| IGRAPH_WARNINGF("The vertex attribute '%s' does not exist. No vertex values will be written.",
------------------
| | 777| 3.11k| do { \
| | 778| 3.11k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.11k| __VA_ARGS__); \
| | 780| 3.11k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.11k]
| | ------------------
------------------
82| 3.11k| vertex_attr_name);
83| 3.11k| vertex_attr_name = NULL;
84| 3.11k| }
85| 3.57k| if (vertex_attr_name) {
------------------
| Branch (85:9): [True: 461, False: 3.11k]
------------------
86| 461| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &vertex_attr_type,
------------------
| | 656| 461| do { \
| | 657| 461| igraph_error_t igraph_i_ret = (expr); \
| | 658| 461| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 461| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 461]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 461| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 461]
| | ------------------
------------------
87| 461| IGRAPH_ATTRIBUTE_VERTEX, vertex_attr_name));
88| 461| if (vertex_attr_type != IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| Branch (88:13): [True: 441, False: 20]
------------------
89| 441| vertex_attr_type != IGRAPH_ATTRIBUTE_STRING &&
------------------
| Branch (89:13): [True: 30, False: 411]
------------------
90| 30| vertex_attr_type != IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (90:13): [True: 0, False: 30]
------------------
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| 461| }
97| |
98| | /* Check if we have the edge attribute */
99| 3.57k| if (edge_attr_name &&
------------------
| Branch (99:9): [True: 3.57k, False: 0]
------------------
100| 3.57k| !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, edge_attr_name)) {
------------------
| Branch (100:9): [True: 3.35k, False: 227]
------------------
101| 3.35k| IGRAPH_WARNINGF("The edge attribute '%s' does not exist. No edge values will be written.",
------------------
| | 777| 3.35k| do { \
| | 778| 3.35k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.35k| __VA_ARGS__); \
| | 780| 3.35k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.35k]
| | ------------------
------------------
102| 3.35k| edge_attr_name);
103| 3.35k| edge_attr_name = NULL;
104| 3.35k| }
105| 3.57k| if (edge_attr_name) {
------------------
| Branch (105:9): [True: 227, False: 3.35k]
------------------
106| 227| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &edge_attr_type,
------------------
| | 656| 227| do { \
| | 657| 227| igraph_error_t igraph_i_ret = (expr); \
| | 658| 227| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 227| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 227]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 227| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 227]
| | ------------------
------------------
107| 227| IGRAPH_ATTRIBUTE_EDGE, edge_attr_name));
108| 227| if (edge_attr_type != IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| Branch (108:13): [True: 52, False: 175]
------------------
109| 52| edge_attr_type != IGRAPH_ATTRIBUTE_STRING &&
------------------
| Branch (109:13): [True: 1, False: 51]
------------------
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| 227| }
117| |
118| | /* Start writing header */
119| 3.57k| CHECK(fprintf(outstream, "LEDA.GRAPH\n"));
------------------
| | 33| 3.57k| do { \
| | 34| 3.57k| int ret=(cmd); \
| | 35| 3.57k| 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.57k]
| | ------------------
| | 36| 3.57k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.57k]
| | ------------------
------------------
120| |
121| 3.57k| switch (vertex_attr_type) {
122| 20| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (122:5): [True: 20, False: 3.55k]
------------------
123| 20| CHECK(fprintf(outstream, "double\n"));
------------------
| | 33| 20| do { \
| | 34| 20| int ret=(cmd); \
| | 35| 20| 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: 20]
| | ------------------
| | 36| 20| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 20]
| | ------------------
------------------
124| 20| break;
125| 411| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (125:5): [True: 411, False: 3.16k]
------------------
126| 411| CHECK(fprintf(outstream, "string\n"));
------------------
| | 33| 411| do { \
| | 34| 411| int ret=(cmd); \
| | 35| 411| 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: 411]
| | ------------------
| | 36| 411| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 411]
| | ------------------
------------------
127| 411| break;
128| 411| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (128:5): [True: 30, False: 3.54k]
------------------
129| 30| CHECK(fprintf(outstream, "bool\n"));
------------------
| | 33| 30| do { \
| | 34| 30| int ret=(cmd); \
| | 35| 30| 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: 30]
| | ------------------
| | 36| 30| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 30]
| | ------------------
------------------
130| 30| break;
131| 3.11k| default:
------------------
| Branch (131:5): [True: 3.11k, False: 461]
------------------
132| 3.11k| CHECK(fprintf(outstream, "void\n"));
------------------
| | 33| 3.11k| do { \
| | 34| 3.11k| int ret=(cmd); \
| | 35| 3.11k| 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.11k]
| | ------------------
| | 36| 3.11k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.11k]
| | ------------------
------------------
133| 3.57k| }
134| |
135| 3.57k| switch (edge_attr_type) {
136| 175| case IGRAPH_ATTRIBUTE_NUMERIC:
------------------
| Branch (136:5): [True: 175, False: 3.40k]
------------------
137| 175| CHECK(fprintf(outstream, "double\n"));
------------------
| | 33| 175| do { \
| | 34| 175| int ret=(cmd); \
| | 35| 175| 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: 175]
| | ------------------
| | 36| 175| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 175]
| | ------------------
------------------
138| 175| break;
139| 175| case IGRAPH_ATTRIBUTE_STRING:
------------------
| Branch (139:5): [True: 51, False: 3.52k]
------------------
140| 51| CHECK(fprintf(outstream, "string\n"));
------------------
| | 33| 51| do { \
| | 34| 51| int ret=(cmd); \
| | 35| 51| 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: 51]
| | ------------------
| | 36| 51| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 51]
| | ------------------
------------------
141| 51| break;
142| 51| case IGRAPH_ATTRIBUTE_BOOLEAN:
------------------
| Branch (142:5): [True: 1, False: 3.57k]
------------------
143| 1| CHECK(fprintf(outstream, "bool\n"));
------------------
| | 33| 1| do { \
| | 34| 1| int ret=(cmd); \
| | 35| 1| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 1]
| | ------------------
| | 36| 1| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 1]
| | ------------------
------------------
144| 1| break;
145| 3.35k| default:
------------------
| Branch (145:5): [True: 3.35k, False: 227]
------------------
146| 3.35k| CHECK(fprintf(outstream, "void\n"));
------------------
| | 33| 3.35k| do { \
| | 34| 3.35k| int ret=(cmd); \
| | 35| 3.35k| 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.35k]
| | ------------------
| | 36| 3.35k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.35k]
| | ------------------
------------------
147| 3.57k| }
148| |
149| 3.57k| CHECK(fprintf(outstream, "%d\n", (igraph_is_directed(graph) ? -1 : -2)));
------------------
| | 33| 3.57k| do { \
| | 34| 7.15k| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 134, False: 3.44k]
| | ------------------
| | 35| 3.57k| 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.57k]
| | ------------------
| | 36| 3.57k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.57k]
| | ------------------
------------------
150| |
151| | /* Start writing vertices */
152| 3.57k| CHECK(fprintf(outstream, "# Vertices\n"));
------------------
| | 33| 3.57k| do { \
| | 34| 3.57k| int ret=(cmd); \
| | 35| 3.57k| 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.57k]
| | ------------------
| | 36| 3.57k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.57k]
| | ------------------
------------------
153| 3.57k| CHECK(fprintf(outstream, "%" IGRAPH_PRId "\n", no_of_nodes));
------------------
| | 33| 3.57k| do { \
| | 34| 3.57k| int ret=(cmd); \
| | 35| 3.57k| 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.57k]
| | ------------------
| | 36| 3.57k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.57k]
| | ------------------
------------------
154| |
155| 3.57k| if (vertex_attr_type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (155:9): [True: 20, False: 3.55k]
------------------
156| | /* Vertices with numeric attributes */
157| 20| igraph_vector_t values;
158| |
159| 20| IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 104| 20| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 105| 20| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 20| do { \
| | | | 604| 20| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 20| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 20| * incorrect destructor function with the pointer */ \
| | | | 607| 20| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 20]
| | | | ------------------
| | | | 608| 20| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 20| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 20]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 20]
| | ------------------
------------------
160| 20| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 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]
| | ------------------
------------------
161| 20| graph, vertex_attr_name, igraph_vss_all(), &values));
162| |
163| 318| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (163:21): [True: 298, False: 20]
------------------
164| 298| CHECK(fprintf(outstream, "|{"));
------------------
| | 33| 298| do { \
| | 34| 298| int ret=(cmd); \
| | 35| 298| 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: 298]
| | ------------------
| | 36| 298| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 298]
| | ------------------
------------------
165| 298| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(values)[i]));
------------------
| | 33| 298| do { \
| | 34| 298| int ret=(cmd); \
| | 35| 298| 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: 298]
| | ------------------
| | 36| 298| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 298]
| | ------------------
------------------
166| 298| CHECK(fprintf(outstream, "}|\n"));
------------------
| | 33| 298| do { \
| | 34| 298| int ret=(cmd); \
| | 35| 298| 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: 298]
| | ------------------
| | 36| 298| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 298]
| | ------------------
------------------
167| 298| }
168| |
169| 20| igraph_vector_destroy(&values);
170| 20| IGRAPH_FINALLY_CLEAN(1);
171| 3.55k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (171:16): [True: 411, False: 3.14k]
------------------
172| | /* Vertices with string attributes */
173| 411| igraph_strvector_t values;
174| |
175| 411| IGRAPH_CHECK(igraph_strvector_init(&values, no_of_nodes));
------------------
| | 656| 411| do { \
| | 657| 411| igraph_error_t igraph_i_ret = (expr); \
| | 658| 411| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 411| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 411]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 411| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 411]
| | ------------------
------------------
176| 411| IGRAPH_FINALLY(igraph_strvector_destroy, &values);
------------------
| | 603| 411| do { \
| | 604| 411| /* the following branch makes the compiler check the compatibility of \
| | 605| 411| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 411| * incorrect destructor function with the pointer */ \
| | 607| 411| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 411]
| | ------------------
| | 608| 411| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 411| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 411]
| | ------------------
------------------
177| |
178| 411| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 411| do { \
| | 657| 411| igraph_error_t igraph_i_ret = (expr); \
| | 658| 411| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 411| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 411]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 411| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 411]
| | ------------------
------------------
179| 411| graph, vertex_attr_name, igraph_vss_all(), &values));
180| |
181| 6.54k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (181:21): [True: 6.17k, False: 371]
------------------
182| 6.17k| const char *str = igraph_strvector_get(&values, i);
183| 6.17k| if (strchr(str, '\n') != 0) {
------------------
| Branch (183:17): [True: 40, False: 6.13k]
------------------
184| 40| IGRAPH_ERROR("Vertex attribute values cannot contain newline characters.",
------------------
| | 426| 40| do { \
| | 427| 40| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 40| return igraph_errno ; \
| | 429| 40| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
185| 40| IGRAPH_EINVAL);
186| 40| }
187| 6.13k| CHECK(fprintf(outstream, "|{%s}|\n", str));
------------------
| | 33| 6.13k| do { \
| | 34| 6.13k| int ret=(cmd); \
| | 35| 6.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: 6.13k]
| | ------------------
| | 36| 6.13k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 6.13k]
| | ------------------
------------------
188| 6.13k| }
189| |
190| 371| igraph_strvector_destroy(&values);
191| 371| IGRAPH_FINALLY_CLEAN(1);
192| 3.14k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (192:16): [True: 30, False: 3.11k]
------------------
193| | /* Vertices with boolean attributes */
194| 30| igraph_vector_bool_t values;
195| |
196| 30| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 109| 30| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 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]
| | | | ------------------
| | ------------------
| | 110| 30| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 30| do { \
| | | | 604| 30| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 30| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 30| * incorrect destructor function with the pointer */ \
| | | | 607| 30| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 30]
| | | | ------------------
| | | | 608| 30| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 30| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 30]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 30]
| | ------------------
------------------
197| 30| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(
------------------
| | 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]
| | ------------------
------------------
198| 30| graph, vertex_attr_name, igraph_vss_all(), &values));
199| |
200| 218| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (200:21): [True: 188, False: 30]
------------------
201| 188| CHECK(fprintf(outstream, "|{%s|}\n", VECTOR(values)[i] ? "true" : "false"));
------------------
| | 33| 188| do { \
| | 34| 376| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 0, False: 188]
| | ------------------
| | 35| 188| 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: 188]
| | ------------------
| | 36| 188| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 188]
| | ------------------
------------------
202| 188| }
203| |
204| 30| igraph_vector_bool_destroy(&values);
205| 30| IGRAPH_FINALLY_CLEAN(1);
206| 3.11k| } else {
207| | /* Vertices with no attributes */
208| 28.7k| for (i = 0; i < no_of_nodes; i++) {
------------------
| Branch (208:21): [True: 25.6k, False: 3.11k]
------------------
209| 25.6k| CHECK(fprintf(outstream, "|{}|\n"));
------------------
| | 33| 25.6k| do { \
| | 34| 25.6k| int ret=(cmd); \
| | 35| 25.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: 25.6k]
| | ------------------
| | 36| 25.6k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 25.6k]
| | ------------------
------------------
210| 25.6k| }
211| 3.11k| }
212| |
213| 3.53k| CHECK(fprintf(outstream, "# Edges\n"));
------------------
| | 33| 3.53k| do { \
| | 34| 3.53k| int ret=(cmd); \
| | 35| 3.53k| 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.53k]
| | ------------------
| | 36| 3.53k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.53k]
| | ------------------
------------------
214| 3.53k| CHECK(fprintf(outstream, "%" IGRAPH_PRId "\n", no_of_edges));
------------------
| | 33| 3.53k| do { \
| | 34| 3.53k| int ret=(cmd); \
| | 35| 3.53k| 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.53k]
| | ------------------
| | 36| 3.53k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 3.53k]
| | ------------------
------------------
215| |
216| 3.53k| if (edge_attr_type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (216:9): [True: 173, False: 3.36k]
------------------
217| | /* Edges with numeric attributes */
218| 173| igraph_vector_t values;
219| 173| IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
------------------
| | 104| 173| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 173| do { \
| | | | 657| 173| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 173| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 173| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 173]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 173| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 173]
| | | | ------------------
| | ------------------
| | 105| 173| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 173| do { \
| | | | 604| 173| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 173| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 173| * incorrect destructor function with the pointer */ \
| | | | 607| 173| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 173]
| | | | ------------------
| | | | 608| 173| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 173| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 173]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 173]
| | ------------------
------------------
220| 173| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 173| do { \
| | 657| 173| igraph_error_t igraph_i_ret = (expr); \
| | 658| 173| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 173| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 173]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 173| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 173]
| | ------------------
------------------
221| 173| graph, edge_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
222| 82.4k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 82.4k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (222:16): [True: 82.3k, False: 173]
------------------
223| 82.3k| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 82.3k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 82.3k]
| | ------------------
| | 406| 82.3k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 82.3k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
224| 82.3k| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 82.3k| do { \
| | 657| 82.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 82.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 82.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.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| 82.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 82.3k]
| | ------------------
------------------
225| 82.3k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 82.3k| do { \
| | 657| 82.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 82.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 82.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.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| 82.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 82.3k]
| | ------------------
------------------
226| 82.3k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 82.3k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 82.3k]
| | ------------------
| | 406| 82.3k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 82.3k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (226:17): [True: 2.96k, False: 79.3k]
------------------
227| 2.96k| rev = -1;
228| 2.96k| }
229| 82.3k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{",
------------------
| | 33| 82.3k| do { \
| | 34| 82.3k| int ret=(cmd); \
| | 35| 82.3k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 82.3k]
| | ------------------
| | 36| 82.3k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 82.3k]
| | ------------------
------------------
230| 82.3k| from + 1, to + 1,
231| 82.3k| rev + 1));
232| 82.3k| CHECK(igraph_real_fprintf_precise(outstream, VECTOR(values)[eid]));
------------------
| | 33| 82.3k| do { \
| | 34| 82.3k| int ret=(cmd); \
| | 35| 82.3k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 82.3k]
| | ------------------
| | 36| 82.3k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 82.3k]
| | ------------------
------------------
233| 82.3k| CHECK(fprintf(outstream, "}|\n"));
------------------
| | 33| 82.3k| do { \
| | 34| 82.3k| int ret=(cmd); \
| | 35| 82.3k| if (ret<0) IGRAPH_ERROR("Writing LEDA format failed.", IGRAPH_EFILE); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | | Branch (35:13): [True: 0, False: 82.3k]
| | ------------------
| | 36| 82.3k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 82.3k]
| | ------------------
------------------
234| 82.3k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 82.3k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
235| 82.3k| }
236| 173| igraph_vector_destroy(&values);
237| 173| IGRAPH_FINALLY_CLEAN(1);
238| 3.36k| } else if (edge_attr_type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (238:16): [True: 51, False: 3.31k]
------------------
239| | /* Edges with string attributes */
240| 51| igraph_strvector_t values;
241| 51| IGRAPH_CHECK(igraph_strvector_init(&values, no_of_nodes));
------------------
| | 656| 51| do { \
| | 657| 51| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 51| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51]
| | ------------------
------------------
242| 51| IGRAPH_FINALLY(igraph_strvector_destroy, &values);
------------------
| | 603| 51| do { \
| | 604| 51| /* the following branch makes the compiler check the compatibility of \
| | 605| 51| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 51| * incorrect destructor function with the pointer */ \
| | 607| 51| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 51]
| | ------------------
| | 608| 51| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 51| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 51]
| | ------------------
------------------
243| 51| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(
------------------
| | 656| 51| do { \
| | 657| 51| igraph_error_t igraph_i_ret = (expr); \
| | 658| 51| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 51| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 51]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 51| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 51]
| | ------------------
------------------
244| 51| graph, edge_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
245| 49.0k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 49.0k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (245:16): [True: 49.0k, False: 50]
------------------
246| 49.0k| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 49.0k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 49.0k]
| | ------------------
| | 406| 49.0k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 49.0k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
247| 49.0k| const char *str = igraph_strvector_get(&values, eid);
248| 49.0k| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 49.0k| do { \
| | 657| 49.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 49.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 49.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49.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| 49.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 49.0k]
| | ------------------
------------------
249| 49.0k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 49.0k| do { \
| | 657| 49.0k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 49.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 49.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 49.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| 49.0k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 49.0k]
| | ------------------
------------------
250| 49.0k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 49.0k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 49.0k]
| | ------------------
| | 406| 49.0k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 49.0k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (250:17): [True: 666, False: 48.3k]
------------------
251| 666| rev = -1;
252| 666| }
253| 49.0k| if (strchr(str, '\n') != 0) {
------------------
| Branch (253:17): [True: 1, False: 49.0k]
------------------
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| 49.0k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{%s}|\n",
------------------
| | 33| 49.0k| do { \
| | 34| 49.0k| int ret=(cmd); \
| | 35| 49.0k| 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.0k]
| | ------------------
| | 36| 49.0k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 49.0k]
| | ------------------
------------------
258| 49.0k| from + 1, to + 1,
259| 49.0k| rev + 1, str));
260| 49.0k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 49.0k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
261| 49.0k| }
262| 50| igraph_strvector_destroy(&values);
263| 50| IGRAPH_FINALLY_CLEAN(1);
264| 3.31k| } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (264:16): [True: 29, False: 3.28k]
------------------
265| | /* Edges with boolean attributes */
266| 29| igraph_vector_bool_t values;
267| |
268| 29| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&values, no_of_edges);
------------------
| | 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]
| | ------------------
------------------
269| 29| IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(
------------------
| | 656| 29| do { \
| | 657| 29| igraph_error_t igraph_i_ret = (expr); \
| | 658| 29| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 29| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 13, False: 16]
| | | | ------------------
| | ------------------
| | 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| 29| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 16]
| | ------------------
------------------
270| 29| graph, vertex_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
271| |
272| 172| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 172|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (272:16): [True: 156, False: 16]
------------------
273| 156| igraph_int_t eid = IGRAPH_EIT_GET(it);
------------------
| | 405| 156| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 156]
| | ------------------
| | 406| 156| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 156|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
274| 156| IGRAPH_CHECK(igraph_edge(graph, eid, &from, &to));
------------------
| | 656| 156| do { \
| | 657| 156| igraph_error_t igraph_i_ret = (expr); \
| | 658| 156| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 156| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 156]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 156| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 156]
| | ------------------
------------------
275| 156| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 156| do { \
| | 657| 156| igraph_error_t igraph_i_ret = (expr); \
| | 658| 156| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 156| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 156]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 156| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 156]
| | ------------------
------------------
276| 156| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 156| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 156]
| | ------------------
| | 406| 156| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 156|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (276:17): [True: 57, False: 99]
------------------
277| 57| rev = -1;
278| 57| }
279| 156| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{%s}|\n",
------------------
| | 33| 156| do { \
| | 34| 312| int ret=(cmd); \
| | ------------------
| | | Branch (34:18): [True: 0, False: 156]
| | ------------------
| | 35| 156| 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: 156]
| | ------------------
| | 36| 156| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 156]
| | ------------------
------------------
280| 156| from + 1, to + 1,
281| 156| rev + 1,
282| 156| VECTOR(values)[eid] ? "true" : "false"));
283| 156| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 156|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
284| 156| }
285| |
286| 16| igraph_vector_bool_destroy(&values);
287| 16| IGRAPH_FINALLY_CLEAN(1);
288| 3.28k| } else {
289| | /* Edges with no attributes */
290| 151k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 151k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (290:16): [True: 148k, False: 3.28k]
------------------
291| 148k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 148k| do { \
| | 657| 296k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 0, False: 148k]
| | ------------------
| | 658| 148k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 148k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 148k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 148k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 148k]
| | ------------------
------------------
292| 148k| IGRAPH_CHECK(igraph_get_eid(graph, &rev, to, from, IGRAPH_DIRECTED, false));
------------------
| | 656| 148k| do { \
| | 657| 148k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 148k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 148k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 148k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 148k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 148k]
| | ------------------
------------------
293| 148k| if (rev == IGRAPH_EIT_GET(it)) {
------------------
| | 405| 148k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 148k]
| | ------------------
| | 406| 148k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 148k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
| Branch (293:17): [True: 16.6k, False: 131k]
------------------
294| 16.6k| rev = -1;
295| 16.6k| }
296| 148k| CHECK(fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " %" IGRAPH_PRId " |{}|\n",
------------------
| | 33| 148k| do { \
| | 34| 148k| int ret=(cmd); \
| | 35| 148k| 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: 148k]
| | ------------------
| | 36| 148k| } while (0)
| | ------------------
| | | Branch (36:14): [Folded, False: 148k]
| | ------------------
------------------
297| 148k| from + 1, to + 1,
298| 148k| rev + 1));
299| 148k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 148k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
300| 148k| }
301| 3.28k| }
302| |
303| 3.52k| igraph_eit_destroy(&it);
304| 3.52k| IGRAPH_FINALLY_CLEAN(1);
305| |
306| 3.52k| return IGRAPH_SUCCESS;
307| 3.53k|}
igraph_read_graph_lgl:
107| 3.42k| igraph_bool_t directed) {
108| |
109| 3.42k| igraph_vector_int_t edges = IGRAPH_VECTOR_NULL;
------------------
| | 99| 3.42k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
------------------
110| 3.42k| igraph_vector_t ws = IGRAPH_VECTOR_NULL;
------------------
| | 99| 3.42k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
------------------
111| 3.42k| igraph_trie_t trie = IGRAPH_TRIE_NULL;
------------------
| | 52| 3.42k| { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 60| 3.42k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 44| 3.42k|#define IGRAPH_VECTOR_PTR_NULL { 0,0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 99| 3.42k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
| | ------------------
| | 53| 3.42k| 0, 0, IGRAPH_STRVECTOR_NULL }
| | ------------------
| | | | 60| 3.42k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
------------------
112| 3.42k| igraph_attribute_record_list_t name, weight;
113| 3.42k| igraph_attribute_record_list_t *pname = NULL, *pweight = NULL;
114| 3.42k| igraph_attribute_record_t *namerec, *weightrec;
115| 3.42k| const char *namestr = "name", *weightstr = "weight";
116| 3.42k| igraph_i_lgl_parsedata_t context;
117| |
118| 3.42k| IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);
------------------
| | 104| 3.42k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.42k| do { \
| | | | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.42k]
| | | | ------------------
| | ------------------
| | 105| 3.42k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.42k| do { \
| | | | 604| 3.42k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.42k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.42k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.42k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.42k]
| | | | ------------------
| | | | 608| 3.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.42k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.42k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.42k]
| | ------------------
------------------
119| 3.42k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0);
------------------
| | 119| 3.42k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.42k| do { \
| | | | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.42k]
| | | | ------------------
| | ------------------
| | 120| 3.42k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.42k| do { \
| | | | 604| 3.42k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.42k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.42k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.42k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.42k]
| | | | ------------------
| | | | 608| 3.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.42k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.42k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.42k]
| | ------------------
------------------
120| 3.42k| IGRAPH_TRIE_INIT_FINALLY(&trie, names);
------------------
| | 55| 3.42k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.42k| do { \
| | | | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.42k]
| | | | ------------------
| | ------------------
| | 56| 3.42k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.42k| do { \
| | | | 604| 3.42k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.42k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.42k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.42k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.42k]
| | | | ------------------
| | | | 608| 3.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.42k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.42k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.42k]
| | ------------------
------------------
121| |
122| 3.42k| context.has_weights = false;
123| 3.42k| context.vector = &edges;
124| 3.42k| context.weights = &ws;
125| 3.42k| context.trie = ≜
126| 3.42k| context.errmsg[0] = '\0';
127| 3.42k| context.igraph_errno = IGRAPH_SUCCESS;
128| |
129| 3.42k| igraph_lgl_yylex_init_extra(&context, &context.scanner);
130| 3.42k| IGRAPH_FINALLY(igraph_lgl_yylex_destroy_wrapper, context.scanner);
------------------
| | 603| 3.42k| do { \
| | 604| 3.42k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.42k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.42k| * incorrect destructor function with the pointer */ \
| | 607| 3.42k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.42k]
| | ------------------
| | 608| 3.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.42k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.42k]
| | ------------------
------------------
131| |
132| 3.42k| igraph_lgl_yyset_in(instream, context.scanner);
133| |
134| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */
135| 3.42k| IGRAPH_FINALLY_ENTER();
136| 3.42k| int err = igraph_lgl_yyparse(&context);
137| 3.42k| IGRAPH_FINALLY_EXIT();
138| 3.42k| switch (err) {
139| 3.42k| case 0: /* success */
------------------
| Branch (139:5): [True: 3.42k, False: 0]
------------------
140| 3.42k| break;
141| 0| case 1: /* parse error */
------------------
| Branch (141:5): [True: 0, False: 3.42k]
------------------
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.42k]
------------------
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.42k]
------------------
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.42k| }
161| |
162| | /* Prepare attributes if needed */
163| 3.42k| if (names) {
------------------
| Branch (163:9): [True: 3.42k, False: 0]
------------------
164| 3.42k| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1));
------------------
| | 656| 3.42k| do { \
| | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.42k]
| | ------------------
------------------
165| 3.42k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name);
------------------
| | 603| 3.42k| do { \
| | 604| 3.42k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.42k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.42k| * incorrect destructor function with the pointer */ \
| | 607| 3.42k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.42k]
| | ------------------
| | 608| 3.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.42k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.42k]
| | ------------------
------------------
166| |
167| 3.42k| namerec = igraph_attribute_record_list_get_ptr(&name, 0);
168| 3.42k| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr));
------------------
| | 656| 3.42k| do { \
| | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.42k]
| | ------------------
------------------
169| 3.42k| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.42k| do { \
| | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.42k]
| | ------------------
------------------
170| 3.42k| IGRAPH_CHECK(igraph_strvector_update(
------------------
| | 656| 3.42k| do { \
| | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.42k]
| | ------------------
------------------
171| 3.42k| namerec->value.as_strvector, igraph_i_trie_borrow_keys(context.trie))
172| 3.42k| );
173| |
174| 3.42k| pname = &name;
175| 3.42k| }
176| |
177| 3.42k| if (weights == IGRAPH_ADD_WEIGHTS_YES ||
------------------
| Branch (177:9): [True: 0, False: 3.42k]
------------------
178| 3.42k| (weights == IGRAPH_ADD_WEIGHTS_IF_PRESENT && context.has_weights)) {
------------------
| Branch (178:10): [True: 3.42k, False: 0]
| Branch (178:54): [True: 148, False: 3.27k]
------------------
179| 148| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1));
------------------
| | 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]
| | ------------------
------------------
180| 148| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight);
------------------
| | 603| 148| do { \
| | 604| 148| /* the following branch makes the compiler check the compatibility of \
| | 605| 148| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 148| * incorrect destructor function with the pointer */ \
| | 607| 148| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 148]
| | ------------------
| | 608| 148| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 148| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 148]
| | ------------------
------------------
181| |
182| 148| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0);
183| 148| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr));
------------------
| | 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]
| | ------------------
------------------
184| 148| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC));
------------------
| | 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]
| | ------------------
------------------
185| 148| igraph_vector_swap(weightrec->value.as_vector, context.weights);
186| |
187| 148| pweight = &weight;
188| 148| }
189| |
190| | /* Create graph */
191| 3.42k| IGRAPH_CHECK(igraph_empty(graph, 0, directed));
------------------
| | 656| 3.42k| do { \
| | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.42k]
| | ------------------
------------------
192| 3.42k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.42k| do { \
| | 604| 3.42k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.42k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.42k| * incorrect destructor function with the pointer */ \
| | 607| 3.42k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.42k]
| | ------------------
| | 608| 3.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.42k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.42k]
| | ------------------
------------------
193| 3.42k| IGRAPH_CHECK(igraph_add_vertices(graph, igraph_trie_size(&trie), pname));
------------------
| | 656| 3.42k| do { \
| | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.42k]
| | ------------------
------------------
194| 3.42k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));
------------------
| | 656| 3.42k| do { \
| | 657| 3.42k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.42k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.42k]
| | ------------------
------------------
195| |
196| 3.42k| if (pweight) {
------------------
| Branch (196:9): [True: 148, False: 3.27k]
------------------
197| 148| igraph_attribute_record_list_destroy(pweight);
198| 148| IGRAPH_FINALLY_CLEAN(1);
199| 148| }
200| 3.42k| if (pname) {
------------------
| Branch (200:9): [True: 3.42k, False: 0]
------------------
201| 3.42k| igraph_attribute_record_list_destroy(pname);
202| 3.42k| IGRAPH_FINALLY_CLEAN(1);
203| 3.42k| }
204| 3.42k| igraph_trie_destroy(&trie);
205| 3.42k| igraph_vector_int_destroy(&edges);
206| 3.42k| igraph_vector_destroy(&ws);
207| 3.42k| igraph_lgl_yylex_destroy(context.scanner);
208| 3.42k| IGRAPH_FINALLY_CLEAN(5);
209| |
210| 3.42k| return IGRAPH_SUCCESS;
211| 3.42k|}
igraph_write_graph_lgl:
271| 3.57k| igraph_bool_t isolates) {
272| 3.57k| igraph_eit_t it;
273| 3.57k| igraph_int_t actvertex = -1;
274| 3.57k| igraph_attribute_type_t nametype, weighttype;
275| 3.57k| const igraph_int_t vcount = igraph_vcount(graph), ecount = igraph_ecount(graph);
276| |
277| 3.57k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM),
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
278| 3.57k| &it));
279| 3.57k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
280| |
281| | /* Check if we have the names attribute */
282| 3.57k| if (names && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
------------------
| Branch (282:9): [True: 3.57k, False: 0]
| Branch (282:18): [True: 3.11k, False: 461]
------------------
283| 3.57k| names)) {
284| 3.11k| IGRAPH_WARNINGF("Names attribute '%s' does not exist.", names);
------------------
| | 777| 3.11k| do { \
| | 778| 3.11k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.11k| __VA_ARGS__); \
| | 780| 3.11k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.11k]
| | ------------------
------------------
285| 3.11k| names = NULL;
286| 3.11k| }
287| 3.57k| if (names) {
------------------
| Branch (287:9): [True: 461, False: 3.11k]
------------------
288| 461| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &nametype,
------------------
| | 656| 461| do { \
| | 657| 461| igraph_error_t igraph_i_ret = (expr); \
| | 658| 461| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 461| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 461]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 461| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 461]
| | ------------------
------------------
289| 461| IGRAPH_ATTRIBUTE_VERTEX, names));
290| 461| if (nametype != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (290:13): [True: 50, False: 411]
------------------
291| 50| IGRAPH_WARNINGF("Ignoring names attribute '%s', unknown attribute type.", names);
------------------
| | 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]
| | ------------------
------------------
292| 50| names = NULL;
293| 50| }
294| 461| }
295| |
296| | /* Check the weights as well */
297| 3.57k| if (weights && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, weights)) {
------------------
| Branch (297:9): [True: 3.57k, False: 0]
| Branch (297:20): [True: 3.35k, False: 227]
------------------
298| 3.35k| IGRAPH_WARNINGF("Weights attribute '%s' does not exist.", weights);
------------------
| | 777| 3.35k| do { \
| | 778| 3.35k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.35k| __VA_ARGS__); \
| | 780| 3.35k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.35k]
| | ------------------
------------------
299| 3.35k| weights = NULL;
300| 3.35k| }
301| 3.57k| if (weights) {
------------------
| Branch (301:9): [True: 227, False: 3.35k]
------------------
302| 227| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &weighttype,
------------------
| | 656| 227| do { \
| | 657| 227| igraph_error_t igraph_i_ret = (expr); \
| | 658| 227| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 227| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 227]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 227| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 227]
| | ------------------
------------------
303| 227| IGRAPH_ATTRIBUTE_EDGE, weights));
304| 227| if (weighttype != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (304:13): [True: 52, False: 175]
------------------
305| 52| IGRAPH_WARNINGF("Ignoring weights attribute '%s', unknown attribute type.", weights);
------------------
| | 777| 52| do { \
| | 778| 52| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 52| __VA_ARGS__); \
| | 780| 52| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 52]
| | ------------------
------------------
306| 52| weights = NULL;
307| 52| }
308| 227| }
309| |
310| 3.57k| if (names == NULL && weights == NULL) {
------------------
| Branch (310:9): [True: 3.16k, False: 411]
| Branch (310:26): [True: 3.05k, False: 108]
------------------
311| | /* No names, no weights */
312| 184k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 184k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (312:16): [True: 181k, False: 3.05k]
------------------
313| 181k| igraph_int_t from, to;
314| 181k| int ret;
315| |
316| 181k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 181k| do { \
| | 657| 362k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 0, False: 181k]
| | ------------------
| | 658| 181k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 181k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 181k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 181k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 181k]
| | ------------------
------------------
317| 181k| if (from == actvertex) {
------------------
| Branch (317:17): [True: 171k, False: 9.99k]
------------------
318| 171k| ret = fprintf(outstream, "%" IGRAPH_PRId "\n", to);
319| 171k| } else {
320| 9.99k| actvertex = from;
321| 9.99k| ret = fprintf(outstream, "# %" IGRAPH_PRId "\n%" IGRAPH_PRId "\n", from, to);
322| 9.99k| }
323| 181k| if (ret < 0) {
------------------
| Branch (323:17): [True: 0, False: 181k]
------------------
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| 181k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 181k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
327| 181k| }
328| 3.05k| } else if (weights == NULL) {
------------------
| Branch (328:16): [True: 344, False: 175]
------------------
329| | /* No weights but use names */
330| 344| igraph_strvector_t nvec;
331| 344| IGRAPH_STRVECTOR_INIT_FINALLY(&nvec, vcount);
------------------
| | 62| 344| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 344| do { \
| | | | 657| 344| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 344]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 344| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 344]
| | | | ------------------
| | ------------------
| | 63| 344| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 344| do { \
| | | | 604| 344| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 344| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 344| * incorrect destructor function with the pointer */ \
| | | | 607| 344| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 344]
| | | | ------------------
| | | | 608| 344| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 344| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 344]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 344]
| | ------------------
------------------
332| 344| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 344| do { \
| | 657| 344| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344]
| | ------------------
------------------
333| 344| igraph_vss_all(),
334| 344| &nvec));
335| 14.9k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 14.9k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (335:16): [True: 14.7k, False: 215]
------------------
336| 14.7k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 14.7k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 14.7k]
| | ------------------
| | 406| 14.7k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 14.7k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
337| 14.7k| igraph_int_t from, to;
338| 14.7k| int ret = 0;
339| 14.7k| const char *str1, *str2;
340| |
341| 14.7k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 14.7k| do { \
| | 657| 14.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 14.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| 14.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.7k]
| | ------------------
------------------
342| 14.7k| str2 = igraph_strvector_get(&nvec, to);
343| 14.7k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 14.7k| do { \
| | 657| 14.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 14.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 14.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 127, False: 14.5k]
| | | | ------------------
| | ------------------
| | 659| 127| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 127| do { \
| | | | 427| 127| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 127| return igraph_errno ; \
| | | | 429| 127| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 127| } \
| | 661| 14.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 14.5k]
| | ------------------
------------------
344| |
345| 14.5k| if (from == actvertex) {
------------------
| Branch (345:17): [True: 12.9k, False: 1.58k]
------------------
346| 12.9k| ret = fprintf(outstream, "%s\n", str2);
347| 12.9k| } else {
348| 1.58k| actvertex = from;
349| 1.58k| str1 = igraph_strvector_get(&nvec, from);
350| 1.58k| IGRAPH_CHECK(check_name(str1));
------------------
| | 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: 2, False: 1.58k]
| | | | ------------------
| | ------------------
| | 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| 1.58k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 1.58k]
| | ------------------
------------------
351| 1.58k| ret = fprintf(outstream, "# %s\n%s\n", str1, str2);
352| 1.58k| }
353| 14.5k| if (ret < 0) {
------------------
| Branch (353:17): [True: 0, False: 14.5k]
------------------
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| 14.5k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 14.5k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
357| 14.5k| }
358| 215| igraph_strvector_destroy(&nvec);
359| 215| IGRAPH_FINALLY_CLEAN(1);
360| 215| } else if (names == NULL) {
------------------
| Branch (360:16): [True: 108, False: 67]
------------------
361| | /* No names but weights */
362| 108| igraph_vector_t wvec;
363| 108| IGRAPH_VECTOR_INIT_FINALLY(&wvec, ecount);
------------------
| | 104| 108| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 108| do { \
| | | | 657| 108| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 108| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 108| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 108]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 108| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 108]
| | | | ------------------
| | ------------------
| | 105| 108| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 108| do { \
| | | | 604| 108| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 108| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 108| * incorrect destructor function with the pointer */ \
| | | | 607| 108| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 108]
| | | | ------------------
| | | | 608| 108| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 108| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 108]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 108]
| | ------------------
------------------
364| 108| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 108| do { \
| | 657| 108| igraph_error_t igraph_i_ret = (expr); \
| | 658| 108| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 108| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 108]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 108| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 108]
| | ------------------
------------------
365| 108| igraph_ess_all(IGRAPH_EDGEORDER_ID),
366| 108| &wvec));
367| 77.2k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 77.2k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (367:16): [True: 77.1k, False: 108]
------------------
368| 77.1k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 77.1k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 77.1k]
| | ------------------
| | 406| 77.1k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 77.1k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
369| 77.1k| igraph_int_t from, to;
370| 77.1k| int ret1, ret2, ret3;
371| |
372| 77.1k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 77.1k| do { \
| | 657| 77.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 77.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 77.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77.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| 77.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 77.1k]
| | ------------------
------------------
373| 77.1k| if (from == actvertex) {
------------------
| Branch (373:17): [True: 76.0k, False: 1.08k]
------------------
374| 76.0k| ret1 = fprintf(outstream, "%" IGRAPH_PRId " ", to);
375| 76.0k| } else {
376| 1.08k| actvertex = from;
377| 1.08k| ret1 = fprintf(outstream, "# %" IGRAPH_PRId "\n%" IGRAPH_PRId " ", from, to);
378| 1.08k| }
379| 77.1k| ret2 = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 77.1k|#define VECTOR(v) ((v).stor_begin)
------------------
380| 77.1k| ret3 = fputc('\n', outstream);
381| 77.1k| if (ret1 < 0 || ret2 < 0 || ret3 == EOF) {
------------------
| Branch (381:17): [True: 0, False: 77.1k]
| Branch (381:29): [True: 0, False: 77.1k]
| Branch (381:41): [True: 0, False: 77.1k]
------------------
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| 77.1k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 77.1k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
385| 77.1k| }
386| 108| igraph_vector_destroy(&wvec);
387| 108| IGRAPH_FINALLY_CLEAN(1);
388| 108| } else {
389| | /* Both names and weights */
390| 67| igraph_strvector_t nvec;
391| 67| igraph_vector_t wvec;
392| 67| IGRAPH_VECTOR_INIT_FINALLY(&wvec, ecount);
------------------
| | 104| 67| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 67| do { \
| | | | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 67]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 67| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 67]
| | | | ------------------
| | ------------------
| | 105| 67| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 67| do { \
| | | | 604| 67| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 67| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 67| * incorrect destructor function with the pointer */ \
| | | | 607| 67| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 67]
| | | | ------------------
| | | | 608| 67| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 67| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 67]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 67]
| | ------------------
------------------
393| 67| IGRAPH_STRVECTOR_INIT_FINALLY(&nvec, vcount);
------------------
| | 62| 67| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 67| do { \
| | | | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 67]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 67| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 67]
| | | | ------------------
| | ------------------
| | 63| 67| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 67| do { \
| | | | 604| 67| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 67| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 67| * incorrect destructor function with the pointer */ \
| | | | 607| 67| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 67]
| | | | ------------------
| | | | 608| 67| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 67| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 67]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 67]
| | ------------------
------------------
394| 67| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 67| do { \
| | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 67]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 67| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 67]
| | ------------------
------------------
395| 67| igraph_ess_all(IGRAPH_EDGEORDER_ID),
396| 67| &wvec));
397| 67| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 67| do { \
| | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 67]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 67| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 67]
| | ------------------
------------------
398| 67| igraph_vss_all(),
399| 67| &nvec));
400| 5.16k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 5.16k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (400:16): [True: 5.12k, False: 44]
------------------
401| 5.12k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 5.12k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 0, False: 5.12k]
| | ------------------
| | 406| 5.12k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 5.12k|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
402| 5.12k| igraph_int_t from, to;
403| 5.12k| int ret = 0, ret2;
404| 5.12k| const char *str1, *str2;
405| |
406| 5.12k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 5.12k| do { \
| | 657| 5.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.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| 5.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.12k]
| | ------------------
------------------
407| 5.12k| str2 = igraph_strvector_get(&nvec, to);
408| 5.12k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 5.12k| do { \
| | 657| 5.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 21, False: 5.09k]
| | | | ------------------
| | ------------------
| | 659| 21| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 21| do { \
| | | | 427| 21| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 21| return igraph_errno ; \
| | | | 429| 21| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 21| } \
| | 661| 5.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.09k]
| | ------------------
------------------
409| |
410| 5.09k| if (from == actvertex) {
------------------
| Branch (410:17): [True: 4.78k, False: 313]
------------------
411| 4.78k| ret = fprintf(outstream, "%s ", str2);
412| 4.78k| } else {
413| 313| actvertex = from;
414| 313| str1 = igraph_strvector_get(&nvec, from);
415| 313| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 313| do { \
| | 657| 313| igraph_error_t igraph_i_ret = (expr); \
| | 658| 313| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 313| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 2, False: 311]
| | | | ------------------
| | ------------------
| | 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| 313| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 311]
| | ------------------
------------------
416| 311| ret = fprintf(outstream, "# %s\n%s ", str1, str2);
417| 311| }
418| 5.09k| if (ret < 0) {
------------------
| Branch (418:17): [True: 0, False: 5.09k]
------------------
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| 5.09k| ret = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 5.09k|#define VECTOR(v) ((v).stor_begin)
------------------
422| 5.09k| ret2 = fputc('\n', outstream);
423| 5.09k| if (ret < 0 || ret2 == EOF) {
------------------
| Branch (423:17): [True: 0, False: 5.09k]
| Branch (423:28): [True: 0, False: 5.09k]
------------------
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| 5.09k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 5.09k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
427| 5.09k| }
428| 44| igraph_strvector_destroy(&nvec);
429| 44| igraph_vector_destroy(&wvec);
430| 44| IGRAPH_FINALLY_CLEAN(2);
431| 44| }
432| |
433| 3.42k| if (isolates) {
------------------
| Branch (433:9): [True: 0, False: 3.42k]
------------------
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.42k| igraph_eit_destroy(&it);
464| 3.42k| IGRAPH_FINALLY_CLEAN(1);
465| 3.42k| return IGRAPH_SUCCESS;
466| 3.42k|}
lgl.c:check_name:
214| 21.7k|static igraph_error_t check_name(const char *name) {
215| 21.7k| size_t len = 0;
216| |
217| 39.5M| for (; *name != '\0'; name++, len++) {
------------------
| Branch (217:12): [True: 39.5M, False: 21.6k]
------------------
218| 39.5M| if ( *name <= 0x020 /* space or non-printable */
------------------
| Branch (218:16): [True: 56, False: 39.5M]
------------------
219| 39.5M| || *name == 0x7f /* del */
------------------
| Branch (219:16): [True: 5, False: 39.5M]
------------------
220| 39.5M| || *name == '#') {
------------------
| Branch (220:16): [True: 57, False: 39.5M]
------------------
221| 118| IGRAPH_ERRORF("The LGL format does not allow non-printable characters, spaces or '#' in vertex names. "
------------------
| | 464| 118| do { \
| | 465| 118| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 118| igraph_errno, __VA_ARGS__) ; \
| | 467| 118| return igraph_errno; \
| | 468| 118| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
222| 118| "Character code 0x%02X found.", IGRAPH_EINVAL,
223| 118| *name);
224| 118| }
225| 39.5M| }
226| 21.6k| if (len == 0) {
------------------
| Branch (226:9): [True: 34, False: 21.5k]
------------------
227| 34| IGRAPH_ERROR("The LGL format does not support empty vertex names.", IGRAPH_EINVAL);
------------------
| | 426| 34| do { \
| | 427| 34| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 34| return igraph_errno ; \
| | 429| 34| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
228| 34| }
229| 21.5k| return IGRAPH_SUCCESS;
230| 21.6k|}
igraph_read_graph_ncol:
110| 3.47k| igraph_bool_t directed) {
111| |
112| 3.47k| igraph_vector_int_t edges;
113| 3.47k| igraph_vector_t ws;
114| 3.47k| igraph_trie_t trie = IGRAPH_TRIE_NULL;
------------------
| | 52| 3.47k| { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 60| 3.47k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 44| 3.47k|#define IGRAPH_VECTOR_PTR_NULL { 0,0,0,0 }
| | ------------------
| | { { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, IGRAPH_VECTOR_NULL}, \
| | ------------------
| | | | 99| 3.47k| #define IGRAPH_VECTOR_NULL { 0,0,0 }
| | ------------------
| | 53| 3.47k| 0, 0, IGRAPH_STRVECTOR_NULL }
| | ------------------
| | | | 60| 3.47k|#define IGRAPH_STRVECTOR_NULL { 0,0,0 }
| | ------------------
------------------
115| 3.47k| igraph_int_t no_of_nodes;
116| 3.47k| igraph_int_t no_predefined = 0;
117| 3.47k| igraph_attribute_record_list_t name, weight;
118| 3.47k| igraph_attribute_record_list_t *pname = NULL, *pweight = NULL;
119| 3.47k| igraph_attribute_record_t *namerec, *weightrec;
120| 3.47k| const char *namestr = "name", *weightstr = "weight";
121| 3.47k| igraph_i_ncol_parsedata_t context;
122| |
123| 3.47k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0);
------------------
| | 119| 3.47k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.47k| do { \
| | | | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.47k]
| | | | ------------------
| | ------------------
| | 120| 3.47k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.47k| do { \
| | | | 604| 3.47k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.47k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.47k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.47k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.47k]
| | | | ------------------
| | | | 608| 3.47k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.47k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.47k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.47k]
| | ------------------
------------------
124| |
125| 3.47k| IGRAPH_TRIE_INIT_FINALLY(&trie, names);
------------------
| | 55| 3.47k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
| | ------------------
| | | | 656| 3.47k| do { \
| | | | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.47k]
| | | | ------------------
| | ------------------
| | 56| 3.47k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)
| | ------------------
| | | | 603| 3.47k| do { \
| | | | 604| 3.47k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.47k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.47k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.47k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.47k]
| | | | ------------------
| | | | 608| 3.47k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.47k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.47k]
| | | | ------------------
| | ------------------
| | | Branch (56:59): [Folded, False: 3.47k]
| | ------------------
------------------
126| 3.47k| IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);
------------------
| | 104| 3.47k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.47k| do { \
| | | | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.47k]
| | | | ------------------
| | ------------------
| | 105| 3.47k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.47k| do { \
| | | | 604| 3.47k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.47k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.47k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.47k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.47k]
| | | | ------------------
| | | | 608| 3.47k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.47k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.47k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.47k]
| | ------------------
------------------
127| |
128| | /* Add the predefined names, if any */
129| 3.47k| if (predefnames != 0) {
------------------
| Branch (129:9): [True: 0, False: 3.47k]
------------------
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.47k| context.has_weights = false;
144| 3.47k| context.vector = &edges;
145| 3.47k| context.weights = &ws;
146| 3.47k| context.trie = ≜
147| 3.47k| context.errmsg[0] = '\0';
148| 3.47k| context.igraph_errno = IGRAPH_SUCCESS;
149| |
150| 3.47k| igraph_ncol_yylex_init_extra(&context, &context.scanner);
151| 3.47k| IGRAPH_FINALLY(igraph_ncol_yylex_destroy_wrapper, context.scanner);
------------------
| | 603| 3.47k| do { \
| | 604| 3.47k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.47k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.47k| * incorrect destructor function with the pointer */ \
| | 607| 3.47k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.47k]
| | ------------------
| | 608| 3.47k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.47k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.47k]
| | ------------------
------------------
152| |
153| 3.47k| igraph_ncol_yyset_in(instream, context.scanner);
154| |
155| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */
156| 3.47k| IGRAPH_FINALLY_ENTER();
157| 3.47k| int err = igraph_ncol_yyparse(&context);
158| 3.47k| IGRAPH_FINALLY_EXIT();
159| 3.47k| switch (err) {
160| 3.47k| case 0: /* success */
------------------
| Branch (160:5): [True: 3.47k, False: 0]
------------------
161| 3.47k| break;
162| 0| case 1: /* parse error */
------------------
| Branch (162:5): [True: 0, False: 3.47k]
------------------
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.47k]
------------------
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.47k]
------------------
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.47k| }
182| |
183| 3.47k| if (predefnames != 0 &&
------------------
| Branch (183:9): [True: 0, False: 3.47k]
------------------
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.47k| if (names) {
------------------
| Branch (189:9): [True: 3.47k, False: 0]
------------------
190| 3.47k| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1));
------------------
| | 656| 3.47k| do { \
| | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.47k]
| | ------------------
------------------
191| 3.47k| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name);
------------------
| | 603| 3.47k| do { \
| | 604| 3.47k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.47k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.47k| * incorrect destructor function with the pointer */ \
| | 607| 3.47k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.47k]
| | ------------------
| | 608| 3.47k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.47k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.47k]
| | ------------------
------------------
192| |
193| 3.47k| namerec = igraph_attribute_record_list_get_ptr(&name, 0);
194| 3.47k| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr));
------------------
| | 656| 3.47k| do { \
| | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.47k]
| | ------------------
------------------
195| 3.47k| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING));
------------------
| | 656| 3.47k| do { \
| | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.47k]
| | ------------------
------------------
196| 3.47k| IGRAPH_CHECK(igraph_strvector_update(
------------------
| | 656| 3.47k| do { \
| | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.47k]
| | ------------------
------------------
197| 3.47k| namerec->value.as_strvector, igraph_i_trie_borrow_keys(context.trie))
198| 3.47k| );
199| |
200| 3.47k| pname = &name;
201| 3.47k| }
202| |
203| 3.47k| if (weights == IGRAPH_ADD_WEIGHTS_YES ||
------------------
| Branch (203:9): [True: 0, False: 3.47k]
------------------
204| 3.47k| (weights == IGRAPH_ADD_WEIGHTS_IF_PRESENT && context.has_weights)) {
------------------
| Branch (204:10): [True: 3.47k, False: 0]
| Branch (204:54): [True: 154, False: 3.32k]
------------------
205| 154| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1));
------------------
| | 656| 154| do { \
| | 657| 154| igraph_error_t igraph_i_ret = (expr); \
| | 658| 154| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 154| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 154]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 154| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 154]
| | ------------------
------------------
206| 154| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight);
------------------
| | 603| 154| do { \
| | 604| 154| /* the following branch makes the compiler check the compatibility of \
| | 605| 154| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 154| * incorrect destructor function with the pointer */ \
| | 607| 154| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 154]
| | ------------------
| | 608| 154| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 154| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 154]
| | ------------------
------------------
207| |
208| 154| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0);
209| 154| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr));
------------------
| | 656| 154| do { \
| | 657| 154| igraph_error_t igraph_i_ret = (expr); \
| | 658| 154| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 154| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 154]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 154| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 154]
| | ------------------
------------------
210| 154| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC));
------------------
| | 656| 154| do { \
| | 657| 154| igraph_error_t igraph_i_ret = (expr); \
| | 658| 154| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 154| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 154]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 154| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 154]
| | ------------------
------------------
211| 154| igraph_vector_swap(weightrec->value.as_vector, context.weights);
212| |
213| 154| pweight = &weight;
214| 154| }
215| |
216| 3.47k| if (igraph_vector_int_empty(&edges)) {
------------------
| Branch (216:9): [True: 968, False: 2.51k]
------------------
217| 968| no_of_nodes = 0;
218| 2.51k| } else {
219| 2.51k| no_of_nodes = igraph_vector_int_max(&edges) + 1;
220| 2.51k| }
221| |
222| | /* Create graph */
223| 3.47k| IGRAPH_CHECK(igraph_empty(graph, 0, directed));
------------------
| | 656| 3.47k| do { \
| | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.47k]
| | ------------------
------------------
224| 3.47k| IGRAPH_FINALLY(igraph_destroy, graph);
------------------
| | 603| 3.47k| do { \
| | 604| 3.47k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.47k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.47k| * incorrect destructor function with the pointer */ \
| | 607| 3.47k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.47k]
| | ------------------
| | 608| 3.47k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.47k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.47k]
| | ------------------
------------------
225| 3.47k| IGRAPH_CHECK(igraph_add_vertices(graph, no_of_nodes, pname));
------------------
| | 656| 3.47k| do { \
| | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.47k]
| | ------------------
------------------
226| 3.47k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));
------------------
| | 656| 3.47k| do { \
| | 657| 3.47k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.47k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.47k]
| | ------------------
------------------
227| |
228| 3.47k| if (pname) {
------------------
| Branch (228:9): [True: 3.47k, False: 0]
------------------
229| 3.47k| igraph_attribute_record_list_destroy(pname);
230| 3.47k| IGRAPH_FINALLY_CLEAN(1);
231| 3.47k| }
232| 3.47k| if (pweight) {
------------------
| Branch (232:9): [True: 154, False: 3.32k]
------------------
233| 154| igraph_attribute_record_list_destroy(pweight);
234| 154| IGRAPH_FINALLY_CLEAN(1);
235| 154| }
236| 3.47k| igraph_vector_destroy(&ws);
237| 3.47k| igraph_trie_destroy(&trie);
238| 3.47k| igraph_vector_int_destroy(&edges);
239| 3.47k| igraph_ncol_yylex_destroy(context.scanner);
240| 3.47k| IGRAPH_FINALLY_CLEAN(5); /* +1 for 'graph' */
241| |
242| 3.47k| return IGRAPH_SUCCESS;
243| 3.47k|}
igraph_write_graph_ncol:
301| 3.57k| const char *names, const char *weights) {
302| 3.57k| igraph_eit_t it;
303| 3.57k| igraph_attribute_type_t nametype, weighttype;
304| |
305| 3.57k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID),
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
306| 3.57k| &it));
307| 3.57k| IGRAPH_FINALLY(igraph_eit_destroy, &it);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
308| |
309| | /* Check if we have the names attribute */
310| 3.57k| if (names && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
------------------
| Branch (310:9): [True: 3.57k, False: 0]
| Branch (310:18): [True: 3.11k, False: 461]
------------------
311| 3.57k| names)) {
312| 3.11k| IGRAPH_WARNINGF("Names attribute '%s' does not exist.", names);
------------------
| | 777| 3.11k| do { \
| | 778| 3.11k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.11k| __VA_ARGS__); \
| | 780| 3.11k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.11k]
| | ------------------
------------------
313| 3.11k| names = NULL;
314| 3.11k| }
315| 3.57k| if (names) {
------------------
| Branch (315:9): [True: 461, False: 3.11k]
------------------
316| 461| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &nametype,
------------------
| | 656| 461| do { \
| | 657| 461| igraph_error_t igraph_i_ret = (expr); \
| | 658| 461| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 461| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 461]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 461| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 461]
| | ------------------
------------------
317| 461| IGRAPH_ATTRIBUTE_VERTEX, names));
318| 461| if (nametype != IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (318:13): [True: 50, False: 411]
------------------
319| 50| IGRAPH_WARNINGF("Ignoring names 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]
| | ------------------
------------------
320| 50| "attribute type is not a string.", names);
321| 50| names = NULL;
322| 50| }
323| 461| }
324| |
325| | /* Check the weights as well */
326| 3.57k| if (weights && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, weights)) {
------------------
| Branch (326:9): [True: 3.57k, False: 0]
| Branch (326:20): [True: 3.35k, False: 227]
------------------
327| 3.35k| IGRAPH_WARNINGF("Weights attribute '%s' does not exist.", weights);
------------------
| | 777| 3.35k| do { \
| | 778| 3.35k| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 3.35k| __VA_ARGS__); \
| | 780| 3.35k| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 3.35k]
| | ------------------
------------------
328| 3.35k| weights = NULL;
329| 3.35k| }
330| 3.57k| if (weights) {
------------------
| Branch (330:9): [True: 227, False: 3.35k]
------------------
331| 227| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &weighttype,
------------------
| | 656| 227| do { \
| | 657| 227| igraph_error_t igraph_i_ret = (expr); \
| | 658| 227| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 227| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 227]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 227| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 227]
| | ------------------
------------------
332| 227| IGRAPH_ATTRIBUTE_EDGE, weights));
333| 227| if (weighttype != IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (333:13): [True: 52, False: 175]
------------------
334| 52| IGRAPH_WARNINGF("Ignoring weights attribute '%s', "
------------------
| | 777| 52| do { \
| | 778| 52| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 779| 52| __VA_ARGS__); \
| | 780| 52| } while (0)
| | ------------------
| | | Branch (780:14): [Folded, False: 52]
| | ------------------
------------------
335| 52| "attribute type is not numeric.", weights);
336| 52| weights = NULL;
337| 52| }
338| 227| }
339| |
340| 3.57k| if (names == NULL && weights == NULL) {
------------------
| Branch (340:9): [True: 3.16k, False: 411]
| Branch (340:26): [True: 3.05k, False: 108]
------------------
341| | /* No names, no weights */
342| 184k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 184k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (342:16): [True: 181k, False: 3.05k]
------------------
343| 181k| igraph_int_t from, to;
344| 181k| int ret;
345| |
346| 181k| IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to));
------------------
| | 656| 181k| do { \
| | 657| 362k| igraph_error_t igraph_i_ret = (expr); \
| | ------------------
| | | Branch (657:40): [True: 181k, False: 0]
| | ------------------
| | 658| 181k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 181k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 181k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 181k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 181k]
| | ------------------
------------------
347| 181k| ret = fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId "\n", from, to);
348| 181k| if (ret < 0) {
------------------
| Branch (348:17): [True: 0, False: 181k]
------------------
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| 181k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 181k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
352| 181k| }
353| 3.05k| } else if (weights == NULL) {
------------------
| Branch (353:16): [True: 344, False: 175]
------------------
354| | /* No weights, but use names */
355| 344| igraph_strvector_t nvec;
356| 344| IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
------------------
| | 656| 344| do { \
| | 657| 344| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344]
| | ------------------
------------------
357| 344| IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
------------------
| | 603| 344| do { \
| | 604| 344| /* the following branch makes the compiler check the compatibility of \
| | 605| 344| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 344| * incorrect destructor function with the pointer */ \
| | 607| 344| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 344]
| | ------------------
| | 608| 344| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 344| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 344]
| | ------------------
------------------
358| 344| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 344| do { \
| | 657| 344| igraph_error_t igraph_i_ret = (expr); \
| | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 344]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 344| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 344]
| | ------------------
------------------
359| 344| igraph_vss_all(),
360| 344| &nvec));
361| 16.0k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 16.0k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (361:16): [True: 15.7k, False: 261]
------------------
362| 15.7k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 15.7k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 15.7k, False: 0]
| | ------------------
| | 406| 15.7k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
363| 15.7k| igraph_int_t from, to;
364| 15.7k| int ret = 0;
365| 15.7k| const char *str1, *str2;
366| |
367| 15.7k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 15.7k| do { \
| | 657| 15.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 15.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 15.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 15.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| 15.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.7k]
| | ------------------
------------------
368| 15.7k| str1 = igraph_strvector_get(&nvec, from);
369| 15.7k| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 15.7k| do { \
| | 657| 15.7k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 15.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 15.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 79, False: 15.6k]
| | | | ------------------
| | ------------------
| | 659| 79| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 79| do { \
| | | | 427| 79| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 79| return igraph_errno ; \
| | | | 429| 79| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 79| } \
| | 661| 15.7k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.6k]
| | ------------------
------------------
370| 15.6k| str2 = igraph_strvector_get(&nvec, to);
371| 15.6k| IGRAPH_CHECK(check_name(str2));
------------------
| | 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: 4, False: 15.6k]
| | | | ------------------
| | ------------------
| | 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| 15.6k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 15.6k]
| | ------------------
------------------
372| 15.6k| ret = fprintf(outstream, "%s %s\n", str1, str2);
373| 15.6k| if (ret < 0) {
------------------
| Branch (373:17): [True: 0, False: 15.6k]
------------------
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.6k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 15.6k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
377| 15.6k| }
378| 261| igraph_strvector_destroy(&nvec);
379| 261| IGRAPH_FINALLY_CLEAN(1);
380| 261| } else if (names == NULL) {
------------------
| Branch (380:16): [True: 108, False: 67]
------------------
381| | /* No names but weights */
382| 108| igraph_vector_t wvec;
383| 108| IGRAPH_VECTOR_INIT_FINALLY(&wvec, igraph_ecount(graph));
------------------
| | 104| 108| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 108| do { \
| | | | 657| 108| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 108| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 108| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 108]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 108| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 108]
| | | | ------------------
| | ------------------
| | 105| 108| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 108| do { \
| | | | 604| 108| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 108| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 108| * incorrect destructor function with the pointer */ \
| | | | 607| 108| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 108]
| | | | ------------------
| | | | 608| 108| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 108| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 108]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 108]
| | ------------------
------------------
384| 108| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 108| do { \
| | 657| 108| igraph_error_t igraph_i_ret = (expr); \
| | 658| 108| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 108| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 108]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 108| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 108]
| | ------------------
------------------
385| 108| igraph_ess_all(IGRAPH_EDGEORDER_ID),
386| 108| &wvec));
387| 77.2k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 77.2k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (387:16): [True: 77.1k, False: 108]
------------------
388| 77.1k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 77.1k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 77.1k, False: 0]
| | ------------------
| | 406| 77.1k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
389| 77.1k| igraph_int_t from, to;
390| 77.1k| int ret1, ret2, ret3;
391| |
392| 77.1k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 77.1k| do { \
| | 657| 77.1k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 77.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 77.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 77.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| 77.1k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 77.1k]
| | ------------------
------------------
393| 77.1k| ret1 = fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId " ", from, to);
394| 77.1k| ret2 = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 77.1k|#define VECTOR(v) ((v).stor_begin)
------------------
395| 77.1k| ret3 = fputc('\n', outstream);
396| 77.1k| if (ret1 < 0 || ret2 < 0 || ret3 == EOF) {
------------------
| Branch (396:17): [True: 0, False: 77.1k]
| Branch (396:29): [True: 0, False: 77.1k]
| Branch (396:41): [True: 0, False: 77.1k]
------------------
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| 77.1k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 77.1k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
400| 77.1k| }
401| 108| igraph_vector_destroy(&wvec);
402| 108| IGRAPH_FINALLY_CLEAN(1);
403| 108| } else {
404| | /* Both names and weights */
405| 67| igraph_strvector_t nvec;
406| 67| igraph_vector_t wvec;
407| 67| IGRAPH_VECTOR_INIT_FINALLY(&wvec, igraph_ecount(graph));
------------------
| | 104| 67| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 67| do { \
| | | | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 67]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 67| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 67]
| | | | ------------------
| | ------------------
| | 105| 67| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 67| do { \
| | | | 604| 67| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 67| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 67| * incorrect destructor function with the pointer */ \
| | | | 607| 67| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 67]
| | | | ------------------
| | | | 608| 67| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 67| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 67]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 67]
| | ------------------
------------------
408| 67| IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
------------------
| | 656| 67| do { \
| | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 67]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 67| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 67]
| | ------------------
------------------
409| 67| IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
------------------
| | 603| 67| do { \
| | 604| 67| /* the following branch makes the compiler check the compatibility of \
| | 605| 67| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 67| * incorrect destructor function with the pointer */ \
| | 607| 67| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 67]
| | ------------------
| | 608| 67| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 67| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 67]
| | ------------------
------------------
410| 67| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
------------------
| | 656| 67| do { \
| | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 67]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 67| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 67]
| | ------------------
------------------
411| 67| igraph_ess_all(IGRAPH_EDGEORDER_ID),
412| 67| &wvec));
413| 67| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
------------------
| | 656| 67| do { \
| | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 67]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 67| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 67]
| | ------------------
------------------
414| 67| igraph_vss_all(),
415| 67| &nvec));
416| 5.17k| while (!IGRAPH_EIT_END(it)) {
------------------
| | 371| 5.17k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end)
------------------
| Branch (416:16): [True: 5.12k, False: 50]
------------------
417| 5.12k| igraph_int_t edge = IGRAPH_EIT_GET(it);
------------------
| | 405| 5.12k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 5.12k, False: 0]
| | ------------------
| | 406| 5.12k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
418| 5.12k| igraph_int_t from, to;
419| 5.12k| int ret = 0, ret2 = 0;
420| 5.12k| const char *str1, *str2;
421| |
422| 5.12k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 5.12k| do { \
| | 657| 5.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 5.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| 5.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.12k]
| | ------------------
------------------
423| 5.12k| str1 = igraph_strvector_get(&nvec, from);
424| 5.12k| IGRAPH_CHECK(check_name(str1));
------------------
| | 656| 5.12k| do { \
| | 657| 5.12k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.12k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.12k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 15, False: 5.11k]
| | | | ------------------
| | ------------------
| | 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| 5.12k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.11k]
| | ------------------
------------------
425| 5.11k| str2 = igraph_strvector_get(&nvec, to);
426| 5.11k| IGRAPH_CHECK(check_name(str2));
------------------
| | 656| 5.11k| do { \
| | 657| 5.11k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 5.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 5.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 2, False: 5.10k]
| | | | ------------------
| | ------------------
| | 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| 5.11k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 5.10k]
| | ------------------
------------------
427| 5.10k| ret = fprintf(outstream, "%s %s ", str1, str2);
428| 5.10k| if (ret < 0) {
------------------
| Branch (428:17): [True: 0, False: 5.10k]
------------------
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| 5.10k| ret = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[edge]);
------------------
| | 60| 5.10k|#define VECTOR(v) ((v).stor_begin)
------------------
432| 5.10k| ret2 = fputc('\n', outstream);
433| 5.10k| if (ret < 0 || ret2 == EOF) {
------------------
| Branch (433:17): [True: 0, False: 5.10k]
| Branch (433:28): [True: 0, False: 5.10k]
------------------
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| 5.10k| IGRAPH_EIT_NEXT(it);
------------------
| | 359| 5.10k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
437| 5.10k| }
438| 50| igraph_strvector_destroy(&nvec);
439| 50| igraph_vector_destroy(&wvec);
440| 50| IGRAPH_FINALLY_CLEAN(2);
441| 50| }
442| |
443| 3.47k| igraph_eit_destroy(&it);
444| 3.47k| IGRAPH_FINALLY_CLEAN(1);
445| 3.47k| return IGRAPH_SUCCESS;
446| 3.57k|}
ncol.c:check_name:
246| 41.7k|static igraph_error_t check_name(const char *name) {
247| 41.7k| size_t len = 0;
248| |
249| 59.7M| for (; *name != '\0'; name++, len++) {
------------------
| Branch (249:12): [True: 59.7M, False: 41.6k]
------------------
250| 59.7M| if ( *name <= 0x020 /* space or non-printable */
------------------
| Branch (250:16): [True: 61, False: 59.7M]
------------------
251| 59.7M| || *name == 0x7f /* del */) {
------------------
| Branch (251:16): [True: 5, False: 59.7M]
------------------
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| 59.7M| }
257| 41.6k| if (len == 0) {
------------------
| Branch (257:9): [True: 34, False: 41.6k]
------------------
258| 34| IGRAPH_ERROR("The NCOL format does not support empty vertex names.", IGRAPH_EINVAL);
------------------
| | 426| 34| do { \
| | 427| 34| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | 428| 34| return igraph_errno ; \
| | 429| 34| } while (0)
| | ------------------
| | | Branch (429:14): [Folded, False: 0]
| | ------------------
------------------
259| 34| }
260| 41.6k| return IGRAPH_SUCCESS;
261| 41.6k|}
igraph_write_graph_pajek:
397| 3.57k|igraph_error_t igraph_write_graph_pajek(const igraph_t *graph, FILE *outstream) {
398| 3.57k| igraph_int_t no_of_nodes = igraph_vcount(graph);
399| |
400| 3.57k| igraph_attribute_type_t vtypes[V_LAST], etypes[E_LAST];
401| 3.57k| igraph_bool_t write_vertex_attrs = false;
402| |
403| | /* Same order as the #define's */
404| 3.57k| const char *vnames[] = { "name", "x", "y", "z", "shape", "xfact", "yfact",
405| 3.57k| "labeldist", "labeldegree2", "framewidth",
406| 3.57k| "fontsize", "rotation", "radius",
407| 3.57k| "diamondratio", "labeldegree",
408| 3.57k| "font", "url", "color", "framecolor",
409| 3.57k| "labelcolor"
410| 3.57k| };
411| 3.57k| IGRAPH_STATIC_ASSERT(sizeof(vnames) / sizeof(vnames[0]) == V_LAST);
------------------
| | 68| 3.57k|#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.57k| const char *vnumnames[] = { "xfact", "yfact", "labeldist",
416| 3.57k| "labeldegree2", "framewidth", "fontsize",
417| 3.57k| "rotation", "radius", "diamondratio",
418| 3.57k| "labeldegree"
419| 3.57k| };
420| 3.57k| const char *vnumnames2[] = { "x_fact", "y_fact", "lr", "lphi", "bw",
421| 3.57k| "fos", "phi", "r", "q", "la"
422| 3.57k| };
423| 3.57k| IGRAPH_STATIC_ASSERT(sizeof(vnumnames) == sizeof(vnumnames2));
------------------
| | 68| 3.57k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
424| |
425| 3.57k| const char *vstrnames[] = { "font", "url", "color", "framecolor",
426| 3.57k| "labelcolor"
427| 3.57k| };
428| 3.57k| const char *vstrnames2[] = { "font", "url", "ic", "bc", "lc" };
429| 3.57k| IGRAPH_STATIC_ASSERT(sizeof(vstrnames) == sizeof(vstrnames2));
------------------
| | 68| 3.57k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
430| |
431| | /* Same order as the #define's */
432| 3.57k| const char *enames[] = { "weight" };
433| 3.57k| IGRAPH_STATIC_ASSERT(sizeof(enames) / sizeof(enames[0]) == E_LAST);
------------------
| | 68| 3.57k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
434| |
435| 3.57k| const char *enumnames[] = { "arrowsize", "edgewidth", "hook1", "hook2",
436| 3.57k| "angle1", "angle2", "velocity1", "velocity2",
437| 3.57k| "arrowpos", "labelpos", "labelangle",
438| 3.57k| "labelangle2", "labeldegree", "fontsize"
439| 3.57k| };
440| 3.57k| const char *enumnames2[] = { "s", "w", "h1", "h2", "a1", "a2", "k1", "k2",
441| 3.57k| "ap", "lp", "lr", "lphi", "la", "fos"
442| 3.57k| };
443| 3.57k| IGRAPH_STATIC_ASSERT(sizeof(enumnames) == sizeof(enumnames2));
------------------
| | 68| 3.57k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
------------------
444| |
445| 3.57k| const char *estrnames[] = { "arrowtype", "linepattern", "label",
446| 3.57k| "labelcolor", "color", "font"
447| 3.57k| };
448| 3.57k| const char *estrnames2[] = { "a", "p", "l", "lc", "c", "font" };
449| 3.57k| IGRAPH_STATIC_ASSERT(sizeof(estrnames) == sizeof(estrnames2));
------------------
| | 68| 3.57k|#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.57k| const char *newline = "\n";
455| |
456| 3.57k| igraph_es_t es;
457| 3.57k| igraph_eit_t eit;
458| |
459| 3.57k| igraph_vector_t numv;
460| 3.57k| igraph_strvector_t strv;
461| |
462| 3.57k| igraph_vector_int_t ex_numa;
463| 3.57k| igraph_vector_int_t ex_stra;
464| 3.57k| igraph_vector_int_t vx_numa;
465| 3.57k| igraph_vector_int_t vx_stra;
466| |
467| 3.57k| const char *s;
468| 3.57k| char *escaped;
469| |
470| 3.57k| igraph_bool_t bipartite = false;
471| 3.57k| igraph_vector_int_t bip_index, bip_index2;
472| 3.57k| igraph_vector_bool_t bvec;
473| 3.57k| igraph_int_t notop = 0, nobottom = 0;
474| |
475| 3.57k| IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
------------------
| | 104| 3.57k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 105| 3.57k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (105:60): [Folded, False: 3.57k]
| | ------------------
------------------
476| 3.57k| IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
------------------
| | 62| 3.57k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 63| 3.57k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (63:65): [Folded, False: 3.57k]
| | ------------------
------------------
477| |
478| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ex_numa, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
479| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ex_stra, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
480| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vx_numa, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
481| 3.57k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vx_stra, 0);
------------------
| | 119| 3.57k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 3.57k| do { \
| | | | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | 120| 3.57k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 3.57k| do { \
| | | | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | | | 607| 3.57k| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 3.57k]
| | | | ------------------
| | | | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 3.57k| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 3.57k]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 3.57k]
| | ------------------
------------------
482| |
483| | /* Check if graph is bipartite, i.e. whether it has a Boolean 'type' vertex attribute. */
484| 3.57k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, "type")) {
------------------
| Branch (484:9): [True: 26, False: 3.55k]
------------------
485| 26| igraph_attribute_type_t type_type;
486| 26| IGRAPH_CHECK(igraph_i_attribute_get_type(graph, &type_type, IGRAPH_ATTRIBUTE_VERTEX, "type"));
------------------
| | 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]
| | ------------------
------------------
487| 26| if (type_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
------------------
| Branch (487:13): [True: 25, False: 1]
------------------
488| 25| 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| 25| IGRAPH_VECTOR_INT_INIT_FINALLY(&bip_index, no_of_nodes);
------------------
| | 119| 25| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 25| do { \
| | | | 657| 25| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 25| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 25| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 25]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 25| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 25]
| | | | ------------------
| | ------------------
| | 120| 25| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 25| do { \
| | | | 604| 25| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 25| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 25| * incorrect destructor function with the pointer */ \
| | | | 607| 25| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 25]
| | | | ------------------
| | | | 608| 25| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 25| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 25]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 25]
| | ------------------
------------------
492| 25| IGRAPH_VECTOR_INT_INIT_FINALLY(&bip_index2, no_of_nodes);
------------------
| | 119| 25| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
| | ------------------
| | | | 656| 25| do { \
| | | | 657| 25| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 25| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 25| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 25]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 25| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 25]
| | | | ------------------
| | ------------------
| | 120| 25| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
| | ------------------
| | | | 603| 25| do { \
| | | | 604| 25| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 25| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 25| * incorrect destructor function with the pointer */ \
| | | | 607| 25| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 25]
| | | | ------------------
| | | | 608| 25| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 25| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 25]
| | | | ------------------
| | ------------------
| | | Branch (120:64): [Folded, False: 25]
| | ------------------
------------------
493| 25| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&bvec, 1);
------------------
| | 109| 25| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
| | ------------------
| | | | 656| 25| do { \
| | | | 657| 25| igraph_error_t igraph_i_ret = (expr); \
| | | | 658| 25| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | | | ------------------
| | | | | | 612| 25| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 25]
| | | | | | ------------------
| | | | ------------------
| | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 660| 0| } \
| | | | 661| 25| } while (0)
| | | | ------------------
| | | | | Branch (661:14): [Folded, False: 25]
| | | | ------------------
| | ------------------
| | 110| 25| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
| | ------------------
| | | | 603| 25| do { \
| | | | 604| 25| /* the following branch makes the compiler check the compatibility of \
| | | | 605| 25| * func and ptr to detect cases when we are accidentally invoking an \
| | | | 606| 25| * incorrect destructor function with the pointer */ \
| | | | 607| 25| if (0) { func(ptr); } \
| | | | ------------------
| | | | | Branch (607:13): [Folded, False: 25]
| | | | ------------------
| | | | 608| 25| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | | | 609| 25| } while (0)
| | | | ------------------
| | | | | Branch (609:14): [Folded, False: 25]
| | | | ------------------
| | ------------------
| | | Branch (110:65): [Folded, False: 25]
| | ------------------
------------------
494| 312| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (494:38): [True: 287, False: 25]
------------------
495| 287| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph,
------------------
| | 656| 287| do { \
| | 657| 287| igraph_error_t igraph_i_ret = (expr); \
| | 658| 287| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 287| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 287]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 287| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 287]
| | ------------------
------------------
496| 287| "type", igraph_vss_1(i), &bvec));
497| 287| if (VECTOR(bvec)[0]) {
------------------
| | 60| 287|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (497:21): [True: 0, False: 287]
------------------
498| 0| notop++;
499| 287| } else {
500| 287| nobottom++;
501| 287| }
502| 287| }
503| 312| for (igraph_int_t i = 0, bptr = 0, tptr = nobottom; i < no_of_nodes; i++) {
------------------
| Branch (503:65): [True: 287, False: 25]
------------------
504| 287| IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph,
------------------
| | 656| 287| do { \
| | 657| 287| igraph_error_t igraph_i_ret = (expr); \
| | 658| 287| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 287| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 287]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 287| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 287]
| | ------------------
------------------
505| 287| "type", igraph_vss_1(i), &bvec));
506| 287| if (VECTOR(bvec)[0]) {
------------------
| | 60| 287|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (506:21): [True: 0, False: 287]
------------------
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| 287| } else {
511| 287| VECTOR(bip_index)[bptr] = i;
------------------
| | 60| 287|#define VECTOR(v) ((v).stor_begin)
------------------
512| 287| VECTOR(bip_index2)[i] = bptr;
------------------
| | 60| 287|#define VECTOR(v) ((v).stor_begin)
------------------
513| 287| bptr++;
514| 287| }
515| 287| }
516| 25| igraph_vector_bool_destroy(&bvec);
517| 25| IGRAPH_FINALLY_CLEAN(1);
518| 25| }
519| 26| }
520| |
521| | /* Write header */
522| 3.57k| if (bipartite) {
------------------
| Branch (522:9): [True: 25, False: 3.55k]
------------------
523| 25| if (fprintf(outstream, "*Vertices %" IGRAPH_PRId " %" IGRAPH_PRId "%s", no_of_nodes, nobottom,
------------------
| Branch (523:13): [True: 0, False: 25]
------------------
524| 25| 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.55k| } else {
528| 3.55k| if (fprintf(outstream, "*Vertices %" IGRAPH_PRId "%s", no_of_nodes, newline) < 0) {
------------------
| Branch (528:13): [True: 0, False: 3.55k]
------------------
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.55k| }
532| |
533| | /* Check the vertex attributes, and determine if we need to write them. */
534| 3.57k| memset(vtypes, 0, sizeof(vtypes[0])*V_LAST);
------------------
| | 263| 3.57k|#define V_LAST 20
------------------
535| 75.1k| for (igraph_int_t i = 0; i < V_LAST; i++) {
------------------
| | 263| 75.1k|#define V_LAST 20
------------------
| Branch (535:30): [True: 71.5k, False: 3.57k]
------------------
536| 71.5k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vnames[i])) {
------------------
| Branch (536:13): [True: 163, False: 71.3k]
------------------
537| 163| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 163| do { \
| | 657| 163| igraph_error_t igraph_i_ret = (expr); \
| | 658| 163| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 163| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 163]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 163| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 163]
| | ------------------
------------------
538| 163| graph, &vtypes[i], IGRAPH_ATTRIBUTE_VERTEX, vnames[i]));
539| 163| write_vertex_attrs = true;
540| 71.3k| } else {
541| 71.3k| vtypes[i] = (igraph_attribute_type_t) -1;
542| 71.3k| }
543| 71.5k| }
544| 39.3k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(vnumnames) / sizeof(vnumnames[0])); i++) {
------------------
| Branch (544:30): [True: 35.7k, False: 3.57k]
------------------
545| 35.7k| igraph_attribute_type_t type;
546| 35.7k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vnumnames[i])) {
------------------
| Branch (546:13): [True: 22, False: 35.7k]
------------------
547| 22| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 22| do { \
| | 657| 22| igraph_error_t igraph_i_ret = (expr); \
| | 658| 22| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 22| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 22]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 22]
| | ------------------
------------------
548| 22| graph, &type, IGRAPH_ATTRIBUTE_VERTEX, vnumnames[i]));
549| 22| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (549:17): [True: 10, False: 12]
------------------
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| 22| }
553| 35.7k| }
554| 21.4k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(vstrnames) / sizeof(vstrnames[0])); i++) {
------------------
| Branch (554:30): [True: 17.8k, False: 3.57k]
------------------
555| 17.8k| igraph_attribute_type_t type;
556| 17.8k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vstrnames[i])) {
------------------
| Branch (556:13): [True: 67, False: 17.8k]
------------------
557| 67| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 67| do { \
| | 657| 67| igraph_error_t igraph_i_ret = (expr); \
| | 658| 67| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 67| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 67]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 67| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 67]
| | ------------------
------------------
558| 67| graph, &type, IGRAPH_ATTRIBUTE_VERTEX, vstrnames[i]));
559| 67| if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (559:17): [True: 61, False: 6]
------------------
560| 61| IGRAPH_CHECK(igraph_vector_int_push_back(&vx_stra, i));
------------------
| | 656| 61| do { \
| | 657| 61| igraph_error_t igraph_i_ret = (expr); \
| | 658| 61| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 61| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 61]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 61| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 61]
| | ------------------
------------------
561| 61| }
562| 67| }
563| 17.8k| }
564| |
565| | /* Write vertices */
566| 3.57k| if (write_vertex_attrs) {
------------------
| Branch (566:9): [True: 186, False: 3.39k]
------------------
567| 2.01k| for (igraph_int_t i = 0; i < no_of_nodes; i++) {
------------------
| Branch (567:34): [True: 1.83k, False: 186]
------------------
568| 1.83k| igraph_int_t id = bipartite ? VECTOR(bip_index)[i] : i;
------------------
| | 60| 287|#define VECTOR(v) ((v).stor_begin)
------------------
| Branch (568:31): [True: 287, False: 1.54k]
------------------
569| |
570| | /* vertex ID */
571| 1.83k| fprintf(outstream, "%" IGRAPH_PRId, i + 1);
------------------
| | 63| 1.83k|# define IGRAPH_PRId PRId64
------------------
572| 1.83k| if (vtypes[V_ID] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 243| 1.83k|#define V_ID 0
------------------
| Branch (572:17): [True: 66, False: 1.76k]
------------------
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.76k| } else if (vtypes[V_ID] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 243| 1.76k|#define V_ID 0
------------------
| Branch (578:24): [True: 162, False: 1.60k]
------------------
579| 162| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 162| do { \
| | 657| 162| igraph_error_t igraph_i_ret = (expr); \
| | 658| 162| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 162| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 162]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 162| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 162]
| | ------------------
------------------
580| 162| graph, vnames[V_ID], igraph_vss_1(id), &strv));
581| 162| s = igraph_strvector_get(&strv, 0);
582| 162| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 162| do { \
| | 657| 162| igraph_error_t igraph_i_ret = (expr); \
| | 658| 162| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 162| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 162]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 162| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 162]
| | ------------------
------------------
583| 162| fprintf(outstream, " %s", escaped);
584| 162| IGRAPH_FREE(escaped);
------------------
| | 36| 162|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
585| 1.60k| } else {
586| 1.60k| fprintf(outstream, " \"%" IGRAPH_PRId "\"", id + 1);
587| 1.60k| }
588| |
589| | /* coordinates */
590| 1.83k| if (vtypes[V_X] == IGRAPH_ATTRIBUTE_NUMERIC &&
------------------
| | 244| 1.83k|#define V_X 1
------------------
| Branch (590:17): [True: 34, False: 1.79k]
------------------
591| 34| vtypes[V_Y] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 245| 34|#define V_Y 2
------------------
| Branch (591:17): [True: 0, False: 34]
------------------
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.83k| if (vtypes[V_SHAPE] == IGRAPH_ATTRIBUTE_STRING) {
------------------
| | 247| 1.83k|#define V_SHAPE 4
------------------
| Branch (609:17): [True: 194, False: 1.63k]
------------------
610| 194| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 194| do { \
| | 657| 194| igraph_error_t igraph_i_ret = (expr); \
| | 658| 194| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 194| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 194]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 194| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 194]
| | ------------------
------------------
611| 194| graph, vnames[V_SHAPE], igraph_vss_1(id), &strv));
612| 194| s = igraph_strvector_get(&strv, 0);
613| 194| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 194| do { \
| | 657| 194| igraph_error_t igraph_i_ret = (expr); \
| | 658| 194| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 194| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 194]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 194| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 194]
| | ------------------
------------------
614| 194| fprintf(outstream, " %s", escaped);
615| 194| IGRAPH_FREE(escaped);
------------------
| | 36| 194|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
616| 194| }
617| |
618| | /* numeric parameters */
619| 2.15k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vx_numa); j++) {
------------------
| Branch (619:38): [True: 322, False: 1.83k]
------------------
620| 322| igraph_int_t idx = VECTOR(vx_numa)[j];
------------------
| | 60| 322|#define VECTOR(v) ((v).stor_begin)
------------------
621| 322| IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
------------------
| | 656| 322| do { \
| | 657| 322| igraph_error_t igraph_i_ret = (expr); \
| | 658| 322| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 322| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 322]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 322| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 322]
| | ------------------
------------------
622| 322| graph, vnumnames[idx], igraph_vss_1(id), &numv));
623| 322| fprintf(outstream, " %s ", vnumnames2[idx]);
624| 322| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 322|#define VECTOR(v) ((v).stor_begin)
------------------
625| 322| }
626| |
627| | /* string parameters */
628| 2.42k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&vx_stra); j++) {
------------------
| Branch (628:38): [True: 599, False: 1.83k]
------------------
629| 599| igraph_int_t idx = VECTOR(vx_stra)[j];
------------------
| | 60| 599|#define VECTOR(v) ((v).stor_begin)
------------------
630| 599| IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
------------------
| | 656| 599| do { \
| | 657| 599| igraph_error_t igraph_i_ret = (expr); \
| | 658| 599| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 599]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 599| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 599]
| | ------------------
------------------
631| 599| graph, vstrnames[idx], igraph_vss_1(id), &strv));
632| 599| s = igraph_strvector_get(&strv, 0);
633| 599| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 599| do { \
| | 657| 599| igraph_error_t igraph_i_ret = (expr); \
| | 658| 599| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 599]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 599| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 599]
| | ------------------
------------------
634| 599| fprintf(outstream, " %s %s", vstrnames2[idx], escaped);
635| 599| IGRAPH_FREE(escaped);
------------------
| | 36| 599|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
636| 599| }
637| |
638| | /* trailing newline */
639| 1.83k| fprintf(outstream, "%s", newline);
640| 1.83k| }
641| 186| }
642| |
643| | /* edges header */
644| 3.57k| if (igraph_is_directed(graph)) {
------------------
| Branch (644:9): [True: 134, False: 3.44k]
------------------
645| 134| fprintf(outstream, "*Arcs%s", newline);
646| 3.44k| } else {
647| 3.44k| fprintf(outstream, "*Edges%s", newline);
648| 3.44k| }
649| |
650| 3.57k| IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_ID));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
651| 3.57k| IGRAPH_FINALLY(igraph_es_destroy, &es);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
652| 3.57k| IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
------------------
| | 656| 3.57k| do { \
| | 657| 3.57k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.57k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, 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.57k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.57k]
| | ------------------
------------------
653| 3.57k| IGRAPH_FINALLY(igraph_eit_destroy, &eit);
------------------
| | 603| 3.57k| do { \
| | 604| 3.57k| /* the following branch makes the compiler check the compatibility of \
| | 605| 3.57k| * func and ptr to detect cases when we are accidentally invoking an \
| | 606| 3.57k| * incorrect destructor function with the pointer */ \
| | 607| 3.57k| if (0) { func(ptr); } \
| | ------------------
| | | Branch (607:13): [Folded, False: 3.57k]
| | ------------------
| | 608| 3.57k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
| | 609| 3.57k| } while (0)
| | ------------------
| | | Branch (609:14): [Folded, False: 3.57k]
| | ------------------
------------------
654| |
655| | /* Check edge attributes */
656| | /* TODO: refactor and simplify since only "weight" is relevant */
657| 7.15k| for (igraph_int_t i = 0; i < E_LAST; i++) {
------------------
| | 266| 7.15k|#define E_LAST 1
------------------
| Branch (657:30): [True: 3.57k, False: 3.57k]
------------------
658| 3.57k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, enames[i])) {
------------------
| Branch (658:13): [True: 227, False: 3.35k]
------------------
659| 227| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 227| do { \
| | 657| 227| igraph_error_t igraph_i_ret = (expr); \
| | 658| 227| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 227| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 227]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 227| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 227]
| | ------------------
------------------
660| 227| graph, &etypes[i], IGRAPH_ATTRIBUTE_EDGE, enames[i]));
661| 3.35k| } else {
662| 3.35k| etypes[i] = (igraph_attribute_type_t) -1;
663| 3.35k| }
664| 3.57k| }
665| 53.6k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(enumnames) / sizeof(enumnames[0])); i++) {
------------------
| Branch (665:30): [True: 50.0k, False: 3.57k]
------------------
666| 50.0k| igraph_attribute_type_t type;
667| 50.0k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, enumnames[i])) {
------------------
| Branch (667:13): [True: 20, False: 50.0k]
------------------
668| 20| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 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]
| | ------------------
------------------
669| 20| graph, &type, IGRAPH_ATTRIBUTE_EDGE, enumnames[i]));
670| 20| if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| Branch (670:17): [True: 15, False: 5]
------------------
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| 20| }
674| 50.0k| }
675| 25.0k| for (igraph_int_t i = 0; i < (igraph_int_t) (sizeof(estrnames) / sizeof(estrnames[0])); i++) {
------------------
| Branch (675:30): [True: 21.4k, False: 3.57k]
------------------
676| 21.4k| igraph_attribute_type_t type;
677| 21.4k| if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, estrnames[i])) {
------------------
| Branch (677:13): [True: 138, False: 21.3k]
------------------
678| 138| IGRAPH_CHECK(igraph_i_attribute_get_type(
------------------
| | 656| 138| do { \
| | 657| 138| igraph_error_t igraph_i_ret = (expr); \
| | 658| 138| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 138| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 138]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 138| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 138]
| | ------------------
------------------
679| 138| graph, &type, IGRAPH_ATTRIBUTE_EDGE, estrnames[i]));
680| 138| if (type == IGRAPH_ATTRIBUTE_STRING) {
------------------
| Branch (680:17): [True: 118, False: 20]
------------------
681| 118| IGRAPH_CHECK(igraph_vector_int_push_back(&ex_stra, i));
------------------
| | 656| 118| do { \
| | 657| 118| igraph_error_t igraph_i_ret = (expr); \
| | 658| 118| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 118| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 118]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 118| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 118]
| | ------------------
------------------
682| 118| }
683| 138| }
684| 21.4k| }
685| |
686| 284k| for (igraph_int_t i = 0; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit), i++) {
------------------
| | 371| 284k|#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| 280k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
------------------
| Branch (686:30): [True: 280k, False: 3.57k]
------------------
687| 280k| igraph_int_t edge = IGRAPH_EIT_GET(eit);
------------------
| | 405| 280k| (igraph_int_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \
| | ------------------
| | | Branch (405:21): [True: 280k, False: 0]
| | ------------------
| | 406| 280k| VECTOR(*(eit).vec)[(eit).pos]))
| | ------------------
| | | | 60| 0|#define VECTOR(v) ((v).stor_begin)
| | ------------------
------------------
688| 280k| igraph_int_t from, to;
689| |
690| 280k| IGRAPH_CHECK(igraph_edge(graph, edge, &from, &to));
------------------
| | 656| 280k| do { \
| | 657| 280k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 280k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 280k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 280k]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 280k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 280k]
| | ------------------
------------------
691| 280k| if (bipartite) {
------------------
| Branch (691:13): [True: 316, False: 280k]
------------------
692| 316| from = VECTOR(bip_index2)[from];
------------------
| | 60| 316|#define VECTOR(v) ((v).stor_begin)
------------------
693| 316| to = VECTOR(bip_index2)[to];
------------------
| | 60| 316|#define VECTOR(v) ((v).stor_begin)
------------------
694| 316| }
695| 280k| fprintf(outstream, "%" IGRAPH_PRId " %" IGRAPH_PRId , from + 1, to + 1);
------------------
| | 63| 280k|# define IGRAPH_PRId PRId64
------------------
696| |
697| | /* Weights */
698| 280k| if (etypes[E_WEIGHT] == IGRAPH_ATTRIBUTE_NUMERIC) {
------------------
| | 265| 280k|#define E_WEIGHT 0
------------------
| Branch (698:13): [True: 82.3k, False: 198k]
------------------
699| 82.3k| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 82.3k| do { \
| | 657| 82.3k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 82.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 82.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 82.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| 82.3k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 82.3k]
| | ------------------
------------------
700| 82.3k| graph, enames[E_WEIGHT], igraph_ess_1(edge), &numv));
701| 82.3k| fputc(' ', outstream);
702| 82.3k| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 82.3k|#define VECTOR(v) ((v).stor_begin)
------------------
703| 82.3k| }
704| |
705| | /* numeric parameters */
706| 280k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&ex_numa); j++) {
------------------
| Branch (706:34): [True: 200, False: 280k]
------------------
707| 200| igraph_int_t idx = VECTOR(ex_numa)[j];
------------------
| | 60| 200|#define VECTOR(v) ((v).stor_begin)
------------------
708| 200| IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
------------------
| | 656| 200| do { \
| | 657| 200| igraph_error_t igraph_i_ret = (expr); \
| | 658| 200| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 200| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 200]
| | | | ------------------
| | ------------------
| | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \
| | ------------------
| | | | 426| 0| do { \
| | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | 428| 0| return igraph_errno ; \
| | | | 429| 0| } while (0)
| | | | ------------------
| | | | | Branch (429:14): [Folded, False: 0]
| | | | ------------------
| | ------------------
| | 660| 0| } \
| | 661| 200| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 200]
| | ------------------
------------------
709| 200| graph, enumnames[idx], igraph_ess_1(edge), &numv));
710| 200| fprintf(outstream, " %s ", enumnames2[idx]);
711| 200| igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
------------------
| | 60| 200|#define VECTOR(v) ((v).stor_begin)
------------------
712| 200| }
713| |
714| | /* string parameters */
715| 283k| for (igraph_int_t j = 0; j < igraph_vector_int_size(&ex_stra); j++) {
------------------
| Branch (715:34): [True: 3.27k, False: 280k]
------------------
716| 3.27k| igraph_int_t idx = VECTOR(ex_stra)[j];
------------------
| | 60| 3.27k|#define VECTOR(v) ((v).stor_begin)
------------------
717| 3.27k| IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(
------------------
| | 656| 3.27k| do { \
| | 657| 3.27k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.27k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.27k]
| | ------------------
------------------
718| 3.27k| graph, estrnames[idx], igraph_ess_1(edge), &strv));
719| 3.27k| s = igraph_strvector_get(&strv, 0);
720| 3.27k| IGRAPH_CHECK(pajek_escape(s, &escaped));
------------------
| | 656| 3.27k| do { \
| | 657| 3.27k| igraph_error_t igraph_i_ret = (expr); \
| | 658| 3.27k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\
| | ------------------
| | | | 612| 3.27k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 3.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| 3.27k| } while (0)
| | ------------------
| | | Branch (661:14): [Folded, False: 3.27k]
| | ------------------
------------------
721| 3.27k| fprintf(outstream, " %s %s", estrnames2[idx], escaped);
722| 3.27k| IGRAPH_FREE(escaped);
------------------
| | 36| 3.27k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
723| 3.27k| }
724| |
725| | /* trailing newline */
726| 280k| fprintf(outstream, "%s", newline);
727| 280k| }
728| |
729| 3.57k| igraph_eit_destroy(&eit);
730| 3.57k| igraph_es_destroy(&es);
731| 3.57k| IGRAPH_FINALLY_CLEAN(2);
732| |
733| 3.57k| if (bipartite) {
------------------
| Branch (733:9): [True: 25, False: 3.55k]
------------------
734| 25| igraph_vector_int_destroy(&bip_index2);
735| 25| igraph_vector_int_destroy(&bip_index);
736| 25| IGRAPH_FINALLY_CLEAN(2);
737| 25| }
738| |
739| 3.57k| igraph_vector_int_destroy(&ex_numa);
740| 3.57k| igraph_vector_int_destroy(&ex_stra);
741| 3.57k| igraph_vector_int_destroy(&vx_numa);
742| 3.57k| igraph_vector_int_destroy(&vx_stra);
743| 3.57k| igraph_strvector_destroy(&strv);
744| 3.57k| igraph_vector_destroy(&numv);
745| 3.57k| IGRAPH_FINALLY_CLEAN(6);
746| 3.57k| return IGRAPH_SUCCESS;
747| 3.57k|}
pajek.c:pajek_escape:
270| 4.23k|static igraph_error_t pajek_escape(const char* src, char** dest) {
271| 4.23k| igraph_int_t destlen = 0;
272| 4.23k| igraph_bool_t need_escape = false;
273| |
274| | /* Determine whether the string contains characters to be escaped */
275| 4.23k| const char *s;
276| 4.23k| char *d;
277| 31.9M| for (s = src; *s; s++, destlen++) {
------------------
| Branch (277:19): [True: 31.9M, False: 4.23k]
------------------
278| 31.9M| if (*s == '\n' || *s == '\r') {
------------------
| Branch (278:13): [True: 1.67M, False: 30.3M]
| Branch (278:27): [True: 200, False: 30.3M]
------------------
279| 1.67M| need_escape = true;
280| 1.67M| destlen++;
281| 30.3M| } else if (*s == '"') {
------------------
| Branch (281:20): [True: 7.26M, False: 23.0M]
------------------
282| 7.26M| need_escape = true;
283| 7.26M| destlen += 4;
284| 23.0M| } else if (!isalnum(*s)) {
------------------
| Branch (284:20): [True: 14.6M, False: 8.42M]
------------------
285| 14.6M| need_escape = true;
286| 14.6M| }
287| 31.9M| }
288| |
289| 4.23k| if (!need_escape) {
------------------
| Branch (289:9): [True: 837, False: 3.39k]
------------------
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| 837| *dest = IGRAPH_CALLOC(destlen + 3, char);
------------------
| | 33| 837|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 1.67k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 837, False: 0]
| | | | | Branch (31:24): [True: 837, False: 0]
| | | | | Branch (31:66): [True: 837, False: 0]
| | | | ------------------
| | ------------------
------------------
297| 837| CHECK_OOM_WP(*dest);
------------------
| | 44| 837|#define CHECK_OOM_WP(p) IGRAPH_CHECK_OOM((p), "Not enough memory to write Pajek format.")
| | ------------------
| | | | 709| 837| do { \
| | | | 710| 837| if (IGRAPH_UNLIKELY(!ptr)) { \
| | | | ------------------
| | | | | | 612| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 837]
| | | | | | ------------------
| | | | ------------------
| | | | 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| 837| } while (0)
| | | | ------------------
| | | | | Branch (713:14): [Folded, False: 837]
| | | | ------------------
| | ------------------
------------------
298| |
299| 837| d = *dest;
300| 837| strcpy(d + 1, src);
301| 837| d[0] = d[destlen + 1] = '"';
302| 837| d[destlen + 2] = 0;
303| 837| return IGRAPH_SUCCESS;
304| 837| }
305| |
306| 3.39k| *dest = IGRAPH_CALLOC(destlen + 3, char);
------------------
| | 33| 3.39k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 6.79k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 3.39k, False: 0]
| | | | | Branch (31:24): [True: 3.39k, False: 0]
| | | | | Branch (31:66): [True: 3.39k, False: 0]
| | | | ------------------
| | ------------------
------------------
307| 3.39k| CHECK_OOM_WP(*dest);
------------------
| | 44| 3.39k|#define CHECK_OOM_WP(p) IGRAPH_CHECK_OOM((p), "Not enough memory to write Pajek format.")
| | ------------------
| | | | 709| 3.39k| do { \
| | | | 710| 3.39k| if (IGRAPH_UNLIKELY(!ptr)) { \
| | | | ------------------
| | | | | | 612| 3.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | | | ------------------
| | | | | | | Branch (612:32): [True: 0, False: 3.39k]
| | | | | | ------------------
| | | | ------------------
| | | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \
| | | | ------------------
| | | | | | 426| 0| do { \
| | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
| | | | | | 428| 0| return igraph_errno ; \
| | | | | | 429| 0| } while (0)
| | | | | | ------------------
| | | | | | | Branch (429:14): [Folded, False: 0]
| | | | | | ------------------
| | | | ------------------
| | | | 712| 0| } \
| | | | 713| 3.39k| } while (0)
| | | | ------------------
| | | | | Branch (713:14): [Folded, False: 3.39k]
| | | | ------------------
| | ------------------
------------------
308| |
309| 3.39k| d = *dest;
310| 3.39k| *d = '"'; d++;
311| |
312| 31.1M| for (s = src; *s; s++, d++) {
------------------
| Branch (312:19): [True: 31.1M, False: 3.39k]
------------------
313| 31.1M| switch (*s) {
314| | /* Encode quotation marks as ", as they would otherwise signify
315| | the end/beginning of a string. */
316| 7.26M| case '"':
------------------
| Branch (316:9): [True: 7.26M, False: 23.8M]
------------------
317| 7.26M| 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.67M| case '\n':
------------------
| Branch (321:9): [True: 1.67M, False: 29.4M]
------------------
322| 1.67M| case '\r':
------------------
| Branch (322:9): [True: 200, False: 31.1M]
------------------
323| 1.67M| *d = '\\'; d++;
324| 1.67M| *d = 'n';
325| 1.67M| break;
326| 22.2M| default:
------------------
| Branch (326:9): [True: 22.2M, False: 8.93M]
------------------
327| 22.2M| *d = *s;
328| 31.1M| }
329| 31.1M| }
330| 3.39k| *d = '"'; d++; *d = 0;
331| |
332| 3.39k| return IGRAPH_SUCCESS;
333| 3.39k|}
igraph_i_trim_whitespace:
33| 18.8k|void igraph_i_trim_whitespace(const char *str, size_t str_len, const char **res, size_t *res_len) {
34| 18.8k| const char *beg = str, *end = str + str_len;
35| 36.5k| while (beg < end && isspace(beg[0]) ) beg++;
------------------
| Branch (35:12): [True: 35.9k, False: 643]
| Branch (35:25): [True: 17.6k, False: 18.2k]
------------------
36| 20.6k| while (end > beg && isspace(end[-1])) end--;
------------------
| Branch (36:12): [True: 19.9k, False: 643]
| Branch (36:25): [True: 1.71k, False: 18.2k]
------------------
37| 18.8k| *res = beg;
38| 18.8k| *res_len = end - beg;
39| 18.8k|}
igraph_i_parse_integer:
52| 1.03k|igraph_error_t igraph_i_parse_integer(const char *str, size_t length, igraph_int_t *value) {
53| 1.03k| char buffer[128];
54| 1.03k| char *tmp, *end;
55| 1.03k| char last_char;
56| 1.03k| igraph_bool_t out_of_range, dynamic_alloc;
57| 1.03k| long long val;
58| |
59| 1.03k| if (length == 0) {
------------------
| Branch (59:9): [True: 0, False: 1.03k]
------------------
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| 1.03k| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]);
64| |
65| 1.03k| if (dynamic_alloc) {
------------------
| Branch (65:9): [True: 13, False: 1.02k]
------------------
66| 13| tmp = IGRAPH_CALLOC(length+1, char);
------------------
| | 33| 13|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 26| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 13, False: 0]
| | | | | Branch (31:24): [True: 13, False: 0]
| | | | | Branch (31:66): [True: 13, False: 0]
| | | | ------------------
| | ------------------
------------------
67| 13| IGRAPH_CHECK_OOM(tmp, "Failed to parse integer.");
------------------
| | 709| 13| do { \
| | 710| 13| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 13| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 13]
| | | | ------------------
| | ------------------
| | 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| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 13]
| | ------------------
------------------
68| 1.02k| } else {
69| 1.02k| tmp = buffer;
70| 1.02k| }
71| |
72| 1.03k| strncpy(tmp, str, length);
73| 1.03k| 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| 1.03k| errno = 0;
79| 1.03k| val = strtoll(tmp, &end, 10);
80| 1.03k| out_of_range = errno == ERANGE;
81| 1.03k| *value = (igraph_int_t) val;
82| 1.03k| last_char = *end;
83| 1.03k| if (*value != val) {
------------------
| Branch (83:9): [True: 0, False: 1.03k]
------------------
84| 0| out_of_range = true;
85| 0| }
86| |
87| | /* Free memory before raising any errors. */
88| 1.03k| if (dynamic_alloc) {
------------------
| Branch (88:9): [True: 13, False: 1.02k]
------------------
89| 13| IGRAPH_FREE(tmp);
------------------
| | 36| 13|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
90| 13| }
91| |
92| 1.03k| if (out_of_range) {
------------------
| Branch (92:9): [True: 1, False: 1.03k]
------------------
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| 1.03k| if (last_char) {
------------------
| Branch (97:9): [True: 22, False: 1.01k]
------------------
98| 22| IGRAPH_ERRORF("Unexpected character '%c' while parsing integer.", IGRAPH_PARSEERROR, last_char);
------------------
| | 464| 22| do { \
| | 465| 22| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
| | 466| 22| igraph_errno, __VA_ARGS__) ; \
| | 467| 22| return igraph_errno; \
| | 468| 22| } while (0)
| | ------------------
| | | Branch (468:14): [Folded, False: 0]
| | ------------------
------------------
99| 22| }
100| |
101| 1.01k| return IGRAPH_SUCCESS;
102| 1.03k|}
igraph_i_parse_real:
113| 785k|igraph_error_t igraph_i_parse_real(const char *str, size_t length, igraph_real_t *value) {
114| 785k| char buffer[128];
115| 785k| char *tmp, *end;
116| 785k| char last_char;
117| 785k| igraph_bool_t out_of_range, dynamic_alloc;
118| |
119| 785k| if (length == 0) {
------------------
| Branch (119:9): [True: 0, False: 785k]
------------------
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| 785k| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]);
124| |
125| 785k| if (dynamic_alloc) {
------------------
| Branch (125:9): [True: 213, False: 785k]
------------------
126| 213| tmp = IGRAPH_CALLOC(length+1, char);
------------------
| | 33| 213|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1))
| | ------------------
| | | | 31| 426| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL)
| | | | ------------------
| | | | | Branch (31:12): [True: 213, False: 0]
| | | | | Branch (31:24): [True: 213, False: 0]
| | | | | Branch (31:66): [True: 213, False: 0]
| | | | ------------------
| | ------------------
------------------
127| 213| IGRAPH_CHECK_OOM(tmp, "Failed to parse real number.");
------------------
| | 709| 213| do { \
| | 710| 213| if (IGRAPH_UNLIKELY(!ptr)) { \
| | ------------------
| | | | 612| 213| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0)
| | | | ------------------
| | | | | Branch (612:32): [True: 0, False: 213]
| | | | ------------------
| | ------------------
| | 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| 213| } while (0)
| | ------------------
| | | Branch (713:14): [Folded, False: 213]
| | ------------------
------------------
128| 785k| } else {
129| 785k| tmp = buffer;
130| 785k| }
131| |
132| 785k| strncpy(tmp, str, length);
133| 785k| tmp[length]='\0';
134| |
135| 785k| errno = 0;
136| 785k| *value = strtod(tmp, &end);
137| 785k| out_of_range = errno == ERANGE; /* This does not trigger when reading +-Inf. */
138| 785k| last_char = *end;
139| |
140| | /* Free memory before raising any errors. */
141| 785k| if (dynamic_alloc) {
------------------
| Branch (141:9): [True: 213, False: 785k]
------------------
142| 213| IGRAPH_FREE(tmp);
------------------
| | 36| 213|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL)
------------------
143| 213| }
144| |
145| 785k| if (out_of_range) {
------------------
| Branch (145:9): [True: 2, False: 785k]
------------------
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| 785k| if (last_char) {
------------------
| Branch (150:9): [True: 16, False: 785k]
------------------
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| 785k| return IGRAPH_SUCCESS;
155| 785k|}
igraph_i_is_real_representable_as_integer:
111| 616k|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| 616k| const igraph_real_t int_max_plus_1 = 2.0 * (IGRAPH_INTEGER_MAX / 2 + 1);
------------------
| | 72| 616k|# define IGRAPH_INTEGER_MAX INT64_MAX
------------------
123| 616k| const igraph_real_t int_min = (igraph_real_t) IGRAPH_INTEGER_MIN;
------------------
| | 73| 616k|# define IGRAPH_INTEGER_MIN INT64_MIN
------------------
124| 616k| if (IGRAPH_LIKELY(int_min <= value && value < int_max_plus_1)) {
------------------
| | 613| 1.23M| #define IGRAPH_LIKELY(a) __builtin_expect(!!(a), 1)
| | ------------------
| | | Branch (613:32): [True: 616k, False: 254]
| | | Branch (613:52): [True: 616k, False: 194]
| | | Branch (613:52): [True: 616k, False: 60]
| | ------------------
------------------
125| 616k| return true;
126| 616k| } else {
127| | return false;
128| 254| }
129| 616k|}